001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.messageboards.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.messageboards.model.MBThreadFlag;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the message boards thread flag service. This utility wraps {@link MBThreadFlagPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see MBThreadFlagPersistence
038     * @see MBThreadFlagPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class MBThreadFlagUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(MBThreadFlag mbThreadFlag) {
060                    getPersistence().clearCache(mbThreadFlag);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<MBThreadFlag> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<MBThreadFlag> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<MBThreadFlag> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<MBThreadFlag> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static MBThreadFlag update(MBThreadFlag mbThreadFlag) {
101                    return getPersistence().update(mbThreadFlag);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static MBThreadFlag update(MBThreadFlag mbThreadFlag,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(mbThreadFlag, serviceContext);
110            }
111    
112            /**
113            * Returns all the message boards thread flags where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching message boards thread flags
117            */
118            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid(
119                    java.lang.String uuid) {
120                    return getPersistence().findByUuid(uuid);
121            }
122    
123            /**
124            * Returns a range of all the message boards thread flags where uuid = &#63;.
125            *
126            * <p>
127            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
128            * </p>
129            *
130            * @param uuid the uuid
131            * @param start the lower bound of the range of message boards thread flags
132            * @param end the upper bound of the range of message boards thread flags (not inclusive)
133            * @return the range of matching message boards thread flags
134            */
135            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid(
136                    java.lang.String uuid, int start, int end) {
137                    return getPersistence().findByUuid(uuid, start, end);
138            }
139    
140            /**
141            * Returns an ordered range of all the message boards thread flags where uuid = &#63;.
142            *
143            * <p>
144            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
145            * </p>
146            *
147            * @param uuid the uuid
148            * @param start the lower bound of the range of message boards thread flags
149            * @param end the upper bound of the range of message boards thread flags (not inclusive)
150            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
151            * @return the ordered range of matching message boards thread flags
152            */
153            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid(
154                    java.lang.String uuid, int start, int end,
155                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
156                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
157            }
158    
159            /**
160            * Returns the first message boards thread flag in the ordered set where uuid = &#63;.
161            *
162            * @param uuid the uuid
163            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
164            * @return the first matching message boards thread flag
165            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found
166            */
167            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUuid_First(
168                    java.lang.String uuid,
169                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
170                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
171                    return getPersistence().findByUuid_First(uuid, orderByComparator);
172            }
173    
174            /**
175            * Returns the first message boards thread flag in the ordered set where uuid = &#63;.
176            *
177            * @param uuid the uuid
178            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
179            * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
180            */
181            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUuid_First(
182                    java.lang.String uuid,
183                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
184                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
185            }
186    
187            /**
188            * Returns the last message boards thread flag in the ordered set where uuid = &#63;.
189            *
190            * @param uuid the uuid
191            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
192            * @return the last matching message boards thread flag
193            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found
194            */
195            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUuid_Last(
196                    java.lang.String uuid,
197                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
198                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
199                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
200            }
201    
202            /**
203            * Returns the last message boards thread flag in the ordered set where uuid = &#63;.
204            *
205            * @param uuid the uuid
206            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
207            * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
208            */
209            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUuid_Last(
210                    java.lang.String uuid,
211                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
212                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where uuid = &#63;.
217            *
218            * @param threadFlagId the primary key of the current message boards thread flag
219            * @param uuid the uuid
220            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
221            * @return the previous, current, and next message boards thread flag
222            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
223            */
224            public static com.liferay.portlet.messageboards.model.MBThreadFlag[] findByUuid_PrevAndNext(
225                    long threadFlagId, java.lang.String uuid,
226                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
227                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
228                    return getPersistence()
229                                       .findByUuid_PrevAndNext(threadFlagId, uuid, orderByComparator);
230            }
231    
232            /**
233            * Removes all the message boards thread flags where uuid = &#63; from the database.
234            *
235            * @param uuid the uuid
236            */
237            public static void removeByUuid(java.lang.String uuid) {
238                    getPersistence().removeByUuid(uuid);
239            }
240    
241            /**
242            * Returns the number of message boards thread flags where uuid = &#63;.
243            *
244            * @param uuid the uuid
245            * @return the number of matching message boards thread flags
246            */
247            public static int countByUuid(java.lang.String uuid) {
248                    return getPersistence().countByUuid(uuid);
249            }
250    
251            /**
252            * Returns the message boards thread flag where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadFlagException} if it could not be found.
253            *
254            * @param uuid the uuid
255            * @param groupId the group ID
256            * @return the matching message boards thread flag
257            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found
258            */
259            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUUID_G(
260                    java.lang.String uuid, long groupId)
261                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
262                    return getPersistence().findByUUID_G(uuid, groupId);
263            }
264    
265            /**
266            * Returns the message boards thread flag where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
267            *
268            * @param uuid the uuid
269            * @param groupId the group ID
270            * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
271            */
272            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUUID_G(
273                    java.lang.String uuid, long groupId) {
274                    return getPersistence().fetchByUUID_G(uuid, groupId);
275            }
276    
277            /**
278            * Returns the message boards thread flag where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
279            *
280            * @param uuid the uuid
281            * @param groupId the group ID
282            * @param retrieveFromCache whether to use the finder cache
283            * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
284            */
285            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUUID_G(
286                    java.lang.String uuid, long groupId, boolean retrieveFromCache) {
287                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
288            }
289    
290            /**
291            * Removes the message boards thread flag where uuid = &#63; and groupId = &#63; from the database.
292            *
293            * @param uuid the uuid
294            * @param groupId the group ID
295            * @return the message boards thread flag that was removed
296            */
297            public static com.liferay.portlet.messageboards.model.MBThreadFlag removeByUUID_G(
298                    java.lang.String uuid, long groupId)
299                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
300                    return getPersistence().removeByUUID_G(uuid, groupId);
301            }
302    
303            /**
304            * Returns the number of message boards thread flags where uuid = &#63; and groupId = &#63;.
305            *
306            * @param uuid the uuid
307            * @param groupId the group ID
308            * @return the number of matching message boards thread flags
309            */
310            public static int countByUUID_G(java.lang.String uuid, long groupId) {
311                    return getPersistence().countByUUID_G(uuid, groupId);
312            }
313    
314            /**
315            * Returns all the message boards thread flags where uuid = &#63; and companyId = &#63;.
316            *
317            * @param uuid the uuid
318            * @param companyId the company ID
319            * @return the matching message boards thread flags
320            */
321            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid_C(
322                    java.lang.String uuid, long companyId) {
323                    return getPersistence().findByUuid_C(uuid, companyId);
324            }
325    
326            /**
327            * Returns a range of all the message boards thread flags where uuid = &#63; and companyId = &#63;.
328            *
329            * <p>
330            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
331            * </p>
332            *
333            * @param uuid the uuid
334            * @param companyId the company ID
335            * @param start the lower bound of the range of message boards thread flags
336            * @param end the upper bound of the range of message boards thread flags (not inclusive)
337            * @return the range of matching message boards thread flags
338            */
339            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid_C(
340                    java.lang.String uuid, long companyId, int start, int end) {
341                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
342            }
343    
344            /**
345            * Returns an ordered range of all the message boards thread flags where uuid = &#63; and companyId = &#63;.
346            *
347            * <p>
348            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
349            * </p>
350            *
351            * @param uuid the uuid
352            * @param companyId the company ID
353            * @param start the lower bound of the range of message boards thread flags
354            * @param end the upper bound of the range of message boards thread flags (not inclusive)
355            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
356            * @return the ordered range of matching message boards thread flags
357            */
358            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUuid_C(
359                    java.lang.String uuid, long companyId, int start, int end,
360                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
361                    return getPersistence()
362                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
363            }
364    
365            /**
366            * Returns the first message boards thread flag in the ordered set where uuid = &#63; and companyId = &#63;.
367            *
368            * @param uuid the uuid
369            * @param companyId the company ID
370            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
371            * @return the first matching message boards thread flag
372            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found
373            */
374            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUuid_C_First(
375                    java.lang.String uuid, long companyId,
376                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
377                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
378                    return getPersistence()
379                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
380            }
381    
382            /**
383            * Returns the first message boards thread flag in the ordered set where uuid = &#63; and companyId = &#63;.
384            *
385            * @param uuid the uuid
386            * @param companyId the company ID
387            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
388            * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
389            */
390            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUuid_C_First(
391                    java.lang.String uuid, long companyId,
392                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
393                    return getPersistence()
394                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
395            }
396    
397            /**
398            * Returns the last message boards thread flag in the ordered set where uuid = &#63; and companyId = &#63;.
399            *
400            * @param uuid the uuid
401            * @param companyId the company ID
402            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
403            * @return the last matching message boards thread flag
404            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found
405            */
406            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUuid_C_Last(
407                    java.lang.String uuid, long companyId,
408                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
409                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
410                    return getPersistence()
411                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
412            }
413    
414            /**
415            * Returns the last message boards thread flag in the ordered set where uuid = &#63; and companyId = &#63;.
416            *
417            * @param uuid the uuid
418            * @param companyId the company ID
419            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
420            * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
421            */
422            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUuid_C_Last(
423                    java.lang.String uuid, long companyId,
424                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
425                    return getPersistence()
426                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
427            }
428    
429            /**
430            * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where uuid = &#63; and companyId = &#63;.
431            *
432            * @param threadFlagId the primary key of the current message boards thread flag
433            * @param uuid the uuid
434            * @param companyId the company ID
435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
436            * @return the previous, current, and next message boards thread flag
437            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
438            */
439            public static com.liferay.portlet.messageboards.model.MBThreadFlag[] findByUuid_C_PrevAndNext(
440                    long threadFlagId, java.lang.String uuid, long companyId,
441                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
442                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
443                    return getPersistence()
444                                       .findByUuid_C_PrevAndNext(threadFlagId, uuid, companyId,
445                            orderByComparator);
446            }
447    
448            /**
449            * Removes all the message boards thread flags where uuid = &#63; and companyId = &#63; from the database.
450            *
451            * @param uuid the uuid
452            * @param companyId the company ID
453            */
454            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
455                    getPersistence().removeByUuid_C(uuid, companyId);
456            }
457    
458            /**
459            * Returns the number of message boards thread flags where uuid = &#63; and companyId = &#63;.
460            *
461            * @param uuid the uuid
462            * @param companyId the company ID
463            * @return the number of matching message boards thread flags
464            */
465            public static int countByUuid_C(java.lang.String uuid, long companyId) {
466                    return getPersistence().countByUuid_C(uuid, companyId);
467            }
468    
469            /**
470            * Returns all the message boards thread flags where userId = &#63;.
471            *
472            * @param userId the user ID
473            * @return the matching message boards thread flags
474            */
475            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUserId(
476                    long userId) {
477                    return getPersistence().findByUserId(userId);
478            }
479    
480            /**
481            * Returns a range of all the message boards thread flags where userId = &#63;.
482            *
483            * <p>
484            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
485            * </p>
486            *
487            * @param userId the user ID
488            * @param start the lower bound of the range of message boards thread flags
489            * @param end the upper bound of the range of message boards thread flags (not inclusive)
490            * @return the range of matching message boards thread flags
491            */
492            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUserId(
493                    long userId, int start, int end) {
494                    return getPersistence().findByUserId(userId, start, end);
495            }
496    
497            /**
498            * Returns an ordered range of all the message boards thread flags where userId = &#63;.
499            *
500            * <p>
501            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
502            * </p>
503            *
504            * @param userId the user ID
505            * @param start the lower bound of the range of message boards thread flags
506            * @param end the upper bound of the range of message boards thread flags (not inclusive)
507            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
508            * @return the ordered range of matching message boards thread flags
509            */
510            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByUserId(
511                    long userId, int start, int end,
512                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
513                    return getPersistence()
514                                       .findByUserId(userId, start, end, orderByComparator);
515            }
516    
517            /**
518            * Returns the first message boards thread flag in the ordered set where userId = &#63;.
519            *
520            * @param userId the user ID
521            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
522            * @return the first matching message boards thread flag
523            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found
524            */
525            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUserId_First(
526                    long userId,
527                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
528                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
529                    return getPersistence().findByUserId_First(userId, orderByComparator);
530            }
531    
532            /**
533            * Returns the first message boards thread flag in the ordered set where userId = &#63;.
534            *
535            * @param userId the user ID
536            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
537            * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
538            */
539            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUserId_First(
540                    long userId,
541                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
542                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
543            }
544    
545            /**
546            * Returns the last message boards thread flag in the ordered set where userId = &#63;.
547            *
548            * @param userId the user ID
549            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
550            * @return the last matching message boards thread flag
551            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found
552            */
553            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByUserId_Last(
554                    long userId,
555                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
556                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
557                    return getPersistence().findByUserId_Last(userId, orderByComparator);
558            }
559    
560            /**
561            * Returns the last message boards thread flag in the ordered set where userId = &#63;.
562            *
563            * @param userId the user ID
564            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
565            * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
566            */
567            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByUserId_Last(
568                    long userId,
569                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
570                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
571            }
572    
573            /**
574            * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where userId = &#63;.
575            *
576            * @param threadFlagId the primary key of the current message boards thread flag
577            * @param userId the user ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the previous, current, and next message boards thread flag
580            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
581            */
582            public static com.liferay.portlet.messageboards.model.MBThreadFlag[] findByUserId_PrevAndNext(
583                    long threadFlagId, long userId,
584                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
585                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
586                    return getPersistence()
587                                       .findByUserId_PrevAndNext(threadFlagId, userId,
588                            orderByComparator);
589            }
590    
591            /**
592            * Removes all the message boards thread flags where userId = &#63; from the database.
593            *
594            * @param userId the user ID
595            */
596            public static void removeByUserId(long userId) {
597                    getPersistence().removeByUserId(userId);
598            }
599    
600            /**
601            * Returns the number of message boards thread flags where userId = &#63;.
602            *
603            * @param userId the user ID
604            * @return the number of matching message boards thread flags
605            */
606            public static int countByUserId(long userId) {
607                    return getPersistence().countByUserId(userId);
608            }
609    
610            /**
611            * Returns all the message boards thread flags where threadId = &#63;.
612            *
613            * @param threadId the thread ID
614            * @return the matching message boards thread flags
615            */
616            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByThreadId(
617                    long threadId) {
618                    return getPersistence().findByThreadId(threadId);
619            }
620    
621            /**
622            * Returns a range of all the message boards thread flags where threadId = &#63;.
623            *
624            * <p>
625            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
626            * </p>
627            *
628            * @param threadId the thread ID
629            * @param start the lower bound of the range of message boards thread flags
630            * @param end the upper bound of the range of message boards thread flags (not inclusive)
631            * @return the range of matching message boards thread flags
632            */
633            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByThreadId(
634                    long threadId, int start, int end) {
635                    return getPersistence().findByThreadId(threadId, start, end);
636            }
637    
638            /**
639            * Returns an ordered range of all the message boards thread flags where threadId = &#63;.
640            *
641            * <p>
642            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
643            * </p>
644            *
645            * @param threadId the thread ID
646            * @param start the lower bound of the range of message boards thread flags
647            * @param end the upper bound of the range of message boards thread flags (not inclusive)
648            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
649            * @return the ordered range of matching message boards thread flags
650            */
651            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findByThreadId(
652                    long threadId, int start, int end,
653                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
654                    return getPersistence()
655                                       .findByThreadId(threadId, start, end, orderByComparator);
656            }
657    
658            /**
659            * Returns the first message boards thread flag in the ordered set where threadId = &#63;.
660            *
661            * @param threadId the thread ID
662            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
663            * @return the first matching message boards thread flag
664            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found
665            */
666            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByThreadId_First(
667                    long threadId,
668                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
669                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
670                    return getPersistence().findByThreadId_First(threadId, orderByComparator);
671            }
672    
673            /**
674            * Returns the first message boards thread flag in the ordered set where threadId = &#63;.
675            *
676            * @param threadId the thread ID
677            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
678            * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
679            */
680            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByThreadId_First(
681                    long threadId,
682                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
683                    return getPersistence()
684                                       .fetchByThreadId_First(threadId, orderByComparator);
685            }
686    
687            /**
688            * Returns the last message boards thread flag in the ordered set where threadId = &#63;.
689            *
690            * @param threadId the thread ID
691            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
692            * @return the last matching message boards thread flag
693            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found
694            */
695            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByThreadId_Last(
696                    long threadId,
697                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
698                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
699                    return getPersistence().findByThreadId_Last(threadId, orderByComparator);
700            }
701    
702            /**
703            * Returns the last message boards thread flag in the ordered set where threadId = &#63;.
704            *
705            * @param threadId the thread ID
706            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
707            * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
708            */
709            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByThreadId_Last(
710                    long threadId,
711                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
712                    return getPersistence().fetchByThreadId_Last(threadId, orderByComparator);
713            }
714    
715            /**
716            * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where threadId = &#63;.
717            *
718            * @param threadFlagId the primary key of the current message boards thread flag
719            * @param threadId the thread ID
720            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
721            * @return the previous, current, and next message boards thread flag
722            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
723            */
724            public static com.liferay.portlet.messageboards.model.MBThreadFlag[] findByThreadId_PrevAndNext(
725                    long threadFlagId, long threadId,
726                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator)
727                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
728                    return getPersistence()
729                                       .findByThreadId_PrevAndNext(threadFlagId, threadId,
730                            orderByComparator);
731            }
732    
733            /**
734            * Removes all the message boards thread flags where threadId = &#63; from the database.
735            *
736            * @param threadId the thread ID
737            */
738            public static void removeByThreadId(long threadId) {
739                    getPersistence().removeByThreadId(threadId);
740            }
741    
742            /**
743            * Returns the number of message boards thread flags where threadId = &#63;.
744            *
745            * @param threadId the thread ID
746            * @return the number of matching message boards thread flags
747            */
748            public static int countByThreadId(long threadId) {
749                    return getPersistence().countByThreadId(threadId);
750            }
751    
752            /**
753            * Returns the message boards thread flag where userId = &#63; and threadId = &#63; or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadFlagException} if it could not be found.
754            *
755            * @param userId the user ID
756            * @param threadId the thread ID
757            * @return the matching message boards thread flag
758            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a matching message boards thread flag could not be found
759            */
760            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByU_T(
761                    long userId, long threadId)
762                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
763                    return getPersistence().findByU_T(userId, threadId);
764            }
765    
766            /**
767            * Returns the message boards thread flag where userId = &#63; and threadId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
768            *
769            * @param userId the user ID
770            * @param threadId the thread ID
771            * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
772            */
773            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByU_T(
774                    long userId, long threadId) {
775                    return getPersistence().fetchByU_T(userId, threadId);
776            }
777    
778            /**
779            * Returns the message boards thread flag where userId = &#63; and threadId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
780            *
781            * @param userId the user ID
782            * @param threadId the thread ID
783            * @param retrieveFromCache whether to use the finder cache
784            * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
785            */
786            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByU_T(
787                    long userId, long threadId, boolean retrieveFromCache) {
788                    return getPersistence().fetchByU_T(userId, threadId, retrieveFromCache);
789            }
790    
791            /**
792            * Removes the message boards thread flag where userId = &#63; and threadId = &#63; from the database.
793            *
794            * @param userId the user ID
795            * @param threadId the thread ID
796            * @return the message boards thread flag that was removed
797            */
798            public static com.liferay.portlet.messageboards.model.MBThreadFlag removeByU_T(
799                    long userId, long threadId)
800                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
801                    return getPersistence().removeByU_T(userId, threadId);
802            }
803    
804            /**
805            * Returns the number of message boards thread flags where userId = &#63; and threadId = &#63;.
806            *
807            * @param userId the user ID
808            * @param threadId the thread ID
809            * @return the number of matching message boards thread flags
810            */
811            public static int countByU_T(long userId, long threadId) {
812                    return getPersistence().countByU_T(userId, threadId);
813            }
814    
815            /**
816            * Caches the message boards thread flag in the entity cache if it is enabled.
817            *
818            * @param mbThreadFlag the message boards thread flag
819            */
820            public static void cacheResult(
821                    com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) {
822                    getPersistence().cacheResult(mbThreadFlag);
823            }
824    
825            /**
826            * Caches the message boards thread flags in the entity cache if it is enabled.
827            *
828            * @param mbThreadFlags the message boards thread flags
829            */
830            public static void cacheResult(
831                    java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> mbThreadFlags) {
832                    getPersistence().cacheResult(mbThreadFlags);
833            }
834    
835            /**
836            * Creates a new message boards thread flag with the primary key. Does not add the message boards thread flag to the database.
837            *
838            * @param threadFlagId the primary key for the new message boards thread flag
839            * @return the new message boards thread flag
840            */
841            public static com.liferay.portlet.messageboards.model.MBThreadFlag create(
842                    long threadFlagId) {
843                    return getPersistence().create(threadFlagId);
844            }
845    
846            /**
847            * Removes the message boards thread flag with the primary key from the database. Also notifies the appropriate model listeners.
848            *
849            * @param threadFlagId the primary key of the message boards thread flag
850            * @return the message boards thread flag that was removed
851            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
852            */
853            public static com.liferay.portlet.messageboards.model.MBThreadFlag remove(
854                    long threadFlagId)
855                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
856                    return getPersistence().remove(threadFlagId);
857            }
858    
859            public static com.liferay.portlet.messageboards.model.MBThreadFlag updateImpl(
860                    com.liferay.portlet.messageboards.model.MBThreadFlag mbThreadFlag) {
861                    return getPersistence().updateImpl(mbThreadFlag);
862            }
863    
864            /**
865            * Returns the message boards thread flag with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadFlagException} if it could not be found.
866            *
867            * @param threadFlagId the primary key of the message boards thread flag
868            * @return the message boards thread flag
869            * @throws com.liferay.portlet.messageboards.NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
870            */
871            public static com.liferay.portlet.messageboards.model.MBThreadFlag findByPrimaryKey(
872                    long threadFlagId)
873                    throws com.liferay.portlet.messageboards.NoSuchThreadFlagException {
874                    return getPersistence().findByPrimaryKey(threadFlagId);
875            }
876    
877            /**
878            * Returns the message boards thread flag with the primary key or returns <code>null</code> if it could not be found.
879            *
880            * @param threadFlagId the primary key of the message boards thread flag
881            * @return the message boards thread flag, or <code>null</code> if a message boards thread flag with the primary key could not be found
882            */
883            public static com.liferay.portlet.messageboards.model.MBThreadFlag fetchByPrimaryKey(
884                    long threadFlagId) {
885                    return getPersistence().fetchByPrimaryKey(threadFlagId);
886            }
887    
888            public static java.util.Map<java.io.Serializable, com.liferay.portlet.messageboards.model.MBThreadFlag> fetchByPrimaryKeys(
889                    java.util.Set<java.io.Serializable> primaryKeys) {
890                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
891            }
892    
893            /**
894            * Returns all the message boards thread flags.
895            *
896            * @return the message boards thread flags
897            */
898            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findAll() {
899                    return getPersistence().findAll();
900            }
901    
902            /**
903            * Returns a range of all the message boards thread flags.
904            *
905            * <p>
906            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
907            * </p>
908            *
909            * @param start the lower bound of the range of message boards thread flags
910            * @param end the upper bound of the range of message boards thread flags (not inclusive)
911            * @return the range of message boards thread flags
912            */
913            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findAll(
914                    int start, int end) {
915                    return getPersistence().findAll(start, end);
916            }
917    
918            /**
919            * Returns an ordered range of all the message boards thread flags.
920            *
921            * <p>
922            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadFlagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
923            * </p>
924            *
925            * @param start the lower bound of the range of message boards thread flags
926            * @param end the upper bound of the range of message boards thread flags (not inclusive)
927            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
928            * @return the ordered range of message boards thread flags
929            */
930            public static java.util.List<com.liferay.portlet.messageboards.model.MBThreadFlag> findAll(
931                    int start, int end,
932                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBThreadFlag> orderByComparator) {
933                    return getPersistence().findAll(start, end, orderByComparator);
934            }
935    
936            /**
937            * Removes all the message boards thread flags from the database.
938            */
939            public static void removeAll() {
940                    getPersistence().removeAll();
941            }
942    
943            /**
944            * Returns the number of message boards thread flags.
945            *
946            * @return the number of message boards thread flags
947            */
948            public static int countAll() {
949                    return getPersistence().countAll();
950            }
951    
952            public static MBThreadFlagPersistence getPersistence() {
953                    if (_persistence == null) {
954                            _persistence = (MBThreadFlagPersistence)PortalBeanLocatorUtil.locate(MBThreadFlagPersistence.class.getName());
955    
956                            ReferenceRegistry.registerReference(MBThreadFlagUtil.class,
957                                    "_persistence");
958                    }
959    
960                    return _persistence;
961            }
962    
963            /**
964             * @deprecated As of 6.2.0
965             */
966            @Deprecated
967            public void setPersistence(MBThreadFlagPersistence persistence) {
968            }
969    
970            private static MBThreadFlagPersistence _persistence;
971    }