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 com.liferay.portlet.messageboards.service.persistence.impl.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 com.liferay.portlet.messageboards.service.persistence.impl.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 List<MBThreadFlag> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the message boards thread flags where uuid = &#63;.
124            *
125            * <p>
126            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of message boards thread flags
131            * @param end the upper bound of the range of message boards thread flags (not inclusive)
132            * @return the range of matching message boards thread flags
133            */
134            public static List<MBThreadFlag> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the message boards thread flags where uuid = &#63;.
141            *
142            * <p>
143            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of message boards thread flags
148            * @param end the upper bound of the range of message boards thread flags (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching message boards thread flags
151            */
152            public static List<MBThreadFlag> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<MBThreadFlag> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns an ordered range of all the message boards thread flags where uuid = &#63;.
159            *
160            * <p>
161            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
162            * </p>
163            *
164            * @param uuid the uuid
165            * @param start the lower bound of the range of message boards thread flags
166            * @param end the upper bound of the range of message boards thread flags (not inclusive)
167            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
168            * @param retrieveFromCache whether to retrieve from the finder cache
169            * @return the ordered range of matching message boards thread flags
170            */
171            public static List<MBThreadFlag> findByUuid(java.lang.String uuid,
172                    int start, int end, OrderByComparator<MBThreadFlag> orderByComparator,
173                    boolean retrieveFromCache) {
174                    return getPersistence()
175                                       .findByUuid(uuid, start, end, orderByComparator,
176                            retrieveFromCache);
177            }
178    
179            /**
180            * Returns the first message boards thread flag in the ordered set where uuid = &#63;.
181            *
182            * @param uuid the uuid
183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
184            * @return the first matching message boards thread flag
185            * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found
186            */
187            public static MBThreadFlag findByUuid_First(java.lang.String uuid,
188                    OrderByComparator<MBThreadFlag> orderByComparator)
189                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
190                    return getPersistence().findByUuid_First(uuid, orderByComparator);
191            }
192    
193            /**
194            * Returns the first message boards thread flag in the ordered set where uuid = &#63;.
195            *
196            * @param uuid the uuid
197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
198            * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
199            */
200            public static MBThreadFlag fetchByUuid_First(java.lang.String uuid,
201                    OrderByComparator<MBThreadFlag> orderByComparator) {
202                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
203            }
204    
205            /**
206            * Returns the last message boards thread flag in the ordered set where uuid = &#63;.
207            *
208            * @param uuid the uuid
209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
210            * @return the last matching message boards thread flag
211            * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found
212            */
213            public static MBThreadFlag findByUuid_Last(java.lang.String uuid,
214                    OrderByComparator<MBThreadFlag> orderByComparator)
215                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
216                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
217            }
218    
219            /**
220            * Returns the last message boards thread flag in the ordered set where uuid = &#63;.
221            *
222            * @param uuid the uuid
223            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
224            * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
225            */
226            public static MBThreadFlag fetchByUuid_Last(java.lang.String uuid,
227                    OrderByComparator<MBThreadFlag> orderByComparator) {
228                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
229            }
230    
231            /**
232            * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where uuid = &#63;.
233            *
234            * @param threadFlagId the primary key of the current message boards thread flag
235            * @param uuid the uuid
236            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
237            * @return the previous, current, and next message boards thread flag
238            * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
239            */
240            public static MBThreadFlag[] findByUuid_PrevAndNext(long threadFlagId,
241                    java.lang.String uuid, OrderByComparator<MBThreadFlag> orderByComparator)
242                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
243                    return getPersistence()
244                                       .findByUuid_PrevAndNext(threadFlagId, uuid, orderByComparator);
245            }
246    
247            /**
248            * Removes all the message boards thread flags where uuid = &#63; from the database.
249            *
250            * @param uuid the uuid
251            */
252            public static void removeByUuid(java.lang.String uuid) {
253                    getPersistence().removeByUuid(uuid);
254            }
255    
256            /**
257            * Returns the number of message boards thread flags where uuid = &#63;.
258            *
259            * @param uuid the uuid
260            * @return the number of matching message boards thread flags
261            */
262            public static int countByUuid(java.lang.String uuid) {
263                    return getPersistence().countByUuid(uuid);
264            }
265    
266            /**
267            * Returns the message boards thread flag where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchThreadFlagException} if it could not be found.
268            *
269            * @param uuid the uuid
270            * @param groupId the group ID
271            * @return the matching message boards thread flag
272            * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found
273            */
274            public static MBThreadFlag findByUUID_G(java.lang.String uuid, long groupId)
275                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
276                    return getPersistence().findByUUID_G(uuid, groupId);
277            }
278    
279            /**
280            * 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.
281            *
282            * @param uuid the uuid
283            * @param groupId the group ID
284            * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
285            */
286            public static MBThreadFlag fetchByUUID_G(java.lang.String uuid, long groupId) {
287                    return getPersistence().fetchByUUID_G(uuid, groupId);
288            }
289    
290            /**
291            * 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.
292            *
293            * @param uuid the uuid
294            * @param groupId the group ID
295            * @param retrieveFromCache whether to retrieve from the finder cache
296            * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
297            */
298            public static MBThreadFlag fetchByUUID_G(java.lang.String uuid,
299                    long groupId, boolean retrieveFromCache) {
300                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
301            }
302    
303            /**
304            * Removes the message boards thread flag where uuid = &#63; and groupId = &#63; from the database.
305            *
306            * @param uuid the uuid
307            * @param groupId the group ID
308            * @return the message boards thread flag that was removed
309            */
310            public static MBThreadFlag removeByUUID_G(java.lang.String uuid,
311                    long groupId)
312                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
313                    return getPersistence().removeByUUID_G(uuid, groupId);
314            }
315    
316            /**
317            * Returns the number of message boards thread flags where uuid = &#63; and groupId = &#63;.
318            *
319            * @param uuid the uuid
320            * @param groupId the group ID
321            * @return the number of matching message boards thread flags
322            */
323            public static int countByUUID_G(java.lang.String uuid, long groupId) {
324                    return getPersistence().countByUUID_G(uuid, groupId);
325            }
326    
327            /**
328            * Returns all the message boards thread flags where uuid = &#63; and companyId = &#63;.
329            *
330            * @param uuid the uuid
331            * @param companyId the company ID
332            * @return the matching message boards thread flags
333            */
334            public static List<MBThreadFlag> findByUuid_C(java.lang.String uuid,
335                    long companyId) {
336                    return getPersistence().findByUuid_C(uuid, companyId);
337            }
338    
339            /**
340            * Returns a range of all the message boards thread flags where uuid = &#63; and companyId = &#63;.
341            *
342            * <p>
343            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
344            * </p>
345            *
346            * @param uuid the uuid
347            * @param companyId the company ID
348            * @param start the lower bound of the range of message boards thread flags
349            * @param end the upper bound of the range of message boards thread flags (not inclusive)
350            * @return the range of matching message boards thread flags
351            */
352            public static List<MBThreadFlag> findByUuid_C(java.lang.String uuid,
353                    long companyId, int start, int end) {
354                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
355            }
356    
357            /**
358            * Returns an ordered range of all the message boards thread flags where uuid = &#63; and companyId = &#63;.
359            *
360            * <p>
361            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
362            * </p>
363            *
364            * @param uuid the uuid
365            * @param companyId the company ID
366            * @param start the lower bound of the range of message boards thread flags
367            * @param end the upper bound of the range of message boards thread flags (not inclusive)
368            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
369            * @return the ordered range of matching message boards thread flags
370            */
371            public static List<MBThreadFlag> findByUuid_C(java.lang.String uuid,
372                    long companyId, int start, int end,
373                    OrderByComparator<MBThreadFlag> orderByComparator) {
374                    return getPersistence()
375                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
376            }
377    
378            /**
379            * Returns an ordered range of all the message boards thread flags where uuid = &#63; and companyId = &#63;.
380            *
381            * <p>
382            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
383            * </p>
384            *
385            * @param uuid the uuid
386            * @param companyId the company ID
387            * @param start the lower bound of the range of message boards thread flags
388            * @param end the upper bound of the range of message boards thread flags (not inclusive)
389            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
390            * @param retrieveFromCache whether to retrieve from the finder cache
391            * @return the ordered range of matching message boards thread flags
392            */
393            public static List<MBThreadFlag> findByUuid_C(java.lang.String uuid,
394                    long companyId, int start, int end,
395                    OrderByComparator<MBThreadFlag> orderByComparator,
396                    boolean retrieveFromCache) {
397                    return getPersistence()
398                                       .findByUuid_C(uuid, companyId, start, end,
399                            orderByComparator, retrieveFromCache);
400            }
401    
402            /**
403            * Returns the first message boards thread flag in the ordered set where uuid = &#63; and companyId = &#63;.
404            *
405            * @param uuid the uuid
406            * @param companyId the company ID
407            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
408            * @return the first matching message boards thread flag
409            * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found
410            */
411            public static MBThreadFlag findByUuid_C_First(java.lang.String uuid,
412                    long companyId, OrderByComparator<MBThreadFlag> orderByComparator)
413                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
414                    return getPersistence()
415                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
416            }
417    
418            /**
419            * Returns the first message boards thread flag in the ordered set where uuid = &#63; and companyId = &#63;.
420            *
421            * @param uuid the uuid
422            * @param companyId the company ID
423            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
424            * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
425            */
426            public static MBThreadFlag fetchByUuid_C_First(java.lang.String uuid,
427                    long companyId, OrderByComparator<MBThreadFlag> orderByComparator) {
428                    return getPersistence()
429                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
430            }
431    
432            /**
433            * Returns the last message boards thread flag in the ordered set where uuid = &#63; and companyId = &#63;.
434            *
435            * @param uuid the uuid
436            * @param companyId the company ID
437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
438            * @return the last matching message boards thread flag
439            * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found
440            */
441            public static MBThreadFlag findByUuid_C_Last(java.lang.String uuid,
442                    long companyId, OrderByComparator<MBThreadFlag> orderByComparator)
443                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
444                    return getPersistence()
445                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
446            }
447    
448            /**
449            * Returns the last message boards thread flag in the ordered set where uuid = &#63; and companyId = &#63;.
450            *
451            * @param uuid the uuid
452            * @param companyId the company ID
453            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
454            * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
455            */
456            public static MBThreadFlag fetchByUuid_C_Last(java.lang.String uuid,
457                    long companyId, OrderByComparator<MBThreadFlag> orderByComparator) {
458                    return getPersistence()
459                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
460            }
461    
462            /**
463            * 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;.
464            *
465            * @param threadFlagId the primary key of the current message boards thread flag
466            * @param uuid the uuid
467            * @param companyId the company ID
468            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
469            * @return the previous, current, and next message boards thread flag
470            * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
471            */
472            public static MBThreadFlag[] findByUuid_C_PrevAndNext(long threadFlagId,
473                    java.lang.String uuid, long companyId,
474                    OrderByComparator<MBThreadFlag> orderByComparator)
475                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
476                    return getPersistence()
477                                       .findByUuid_C_PrevAndNext(threadFlagId, uuid, companyId,
478                            orderByComparator);
479            }
480    
481            /**
482            * Removes all the message boards thread flags where uuid = &#63; and companyId = &#63; from the database.
483            *
484            * @param uuid the uuid
485            * @param companyId the company ID
486            */
487            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
488                    getPersistence().removeByUuid_C(uuid, companyId);
489            }
490    
491            /**
492            * Returns the number of message boards thread flags where uuid = &#63; and companyId = &#63;.
493            *
494            * @param uuid the uuid
495            * @param companyId the company ID
496            * @return the number of matching message boards thread flags
497            */
498            public static int countByUuid_C(java.lang.String uuid, long companyId) {
499                    return getPersistence().countByUuid_C(uuid, companyId);
500            }
501    
502            /**
503            * Returns all the message boards thread flags where userId = &#63;.
504            *
505            * @param userId the user ID
506            * @return the matching message boards thread flags
507            */
508            public static List<MBThreadFlag> findByUserId(long userId) {
509                    return getPersistence().findByUserId(userId);
510            }
511    
512            /**
513            * Returns a range of all the message boards thread flags where userId = &#63;.
514            *
515            * <p>
516            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
517            * </p>
518            *
519            * @param userId the user ID
520            * @param start the lower bound of the range of message boards thread flags
521            * @param end the upper bound of the range of message boards thread flags (not inclusive)
522            * @return the range of matching message boards thread flags
523            */
524            public static List<MBThreadFlag> findByUserId(long userId, int start,
525                    int end) {
526                    return getPersistence().findByUserId(userId, start, end);
527            }
528    
529            /**
530            * Returns an ordered range of all the message boards thread flags where userId = &#63;.
531            *
532            * <p>
533            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
534            * </p>
535            *
536            * @param userId the user ID
537            * @param start the lower bound of the range of message boards thread flags
538            * @param end the upper bound of the range of message boards thread flags (not inclusive)
539            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
540            * @return the ordered range of matching message boards thread flags
541            */
542            public static List<MBThreadFlag> findByUserId(long userId, int start,
543                    int end, OrderByComparator<MBThreadFlag> orderByComparator) {
544                    return getPersistence()
545                                       .findByUserId(userId, start, end, orderByComparator);
546            }
547    
548            /**
549            * Returns an ordered range of all the message boards thread flags where userId = &#63;.
550            *
551            * <p>
552            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
553            * </p>
554            *
555            * @param userId the user ID
556            * @param start the lower bound of the range of message boards thread flags
557            * @param end the upper bound of the range of message boards thread flags (not inclusive)
558            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
559            * @param retrieveFromCache whether to retrieve from the finder cache
560            * @return the ordered range of matching message boards thread flags
561            */
562            public static List<MBThreadFlag> findByUserId(long userId, int start,
563                    int end, OrderByComparator<MBThreadFlag> orderByComparator,
564                    boolean retrieveFromCache) {
565                    return getPersistence()
566                                       .findByUserId(userId, start, end, orderByComparator,
567                            retrieveFromCache);
568            }
569    
570            /**
571            * Returns the first message boards thread flag in the ordered set where userId = &#63;.
572            *
573            * @param userId the user ID
574            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
575            * @return the first matching message boards thread flag
576            * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found
577            */
578            public static MBThreadFlag findByUserId_First(long userId,
579                    OrderByComparator<MBThreadFlag> orderByComparator)
580                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
581                    return getPersistence().findByUserId_First(userId, orderByComparator);
582            }
583    
584            /**
585            * Returns the first message boards thread flag in the ordered set where userId = &#63;.
586            *
587            * @param userId the user ID
588            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
589            * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
590            */
591            public static MBThreadFlag fetchByUserId_First(long userId,
592                    OrderByComparator<MBThreadFlag> orderByComparator) {
593                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
594            }
595    
596            /**
597            * Returns the last message boards thread flag in the ordered set where userId = &#63;.
598            *
599            * @param userId the user ID
600            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
601            * @return the last matching message boards thread flag
602            * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found
603            */
604            public static MBThreadFlag findByUserId_Last(long userId,
605                    OrderByComparator<MBThreadFlag> orderByComparator)
606                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
607                    return getPersistence().findByUserId_Last(userId, orderByComparator);
608            }
609    
610            /**
611            * Returns the last message boards thread flag in the ordered set where userId = &#63;.
612            *
613            * @param userId the user ID
614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
615            * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
616            */
617            public static MBThreadFlag fetchByUserId_Last(long userId,
618                    OrderByComparator<MBThreadFlag> orderByComparator) {
619                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
620            }
621    
622            /**
623            * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where userId = &#63;.
624            *
625            * @param threadFlagId the primary key of the current message boards thread flag
626            * @param userId the user ID
627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
628            * @return the previous, current, and next message boards thread flag
629            * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
630            */
631            public static MBThreadFlag[] findByUserId_PrevAndNext(long threadFlagId,
632                    long userId, OrderByComparator<MBThreadFlag> orderByComparator)
633                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
634                    return getPersistence()
635                                       .findByUserId_PrevAndNext(threadFlagId, userId,
636                            orderByComparator);
637            }
638    
639            /**
640            * Removes all the message boards thread flags where userId = &#63; from the database.
641            *
642            * @param userId the user ID
643            */
644            public static void removeByUserId(long userId) {
645                    getPersistence().removeByUserId(userId);
646            }
647    
648            /**
649            * Returns the number of message boards thread flags where userId = &#63;.
650            *
651            * @param userId the user ID
652            * @return the number of matching message boards thread flags
653            */
654            public static int countByUserId(long userId) {
655                    return getPersistence().countByUserId(userId);
656            }
657    
658            /**
659            * Returns all the message boards thread flags where threadId = &#63;.
660            *
661            * @param threadId the thread ID
662            * @return the matching message boards thread flags
663            */
664            public static List<MBThreadFlag> findByThreadId(long threadId) {
665                    return getPersistence().findByThreadId(threadId);
666            }
667    
668            /**
669            * Returns a range of all the message boards thread flags where threadId = &#63;.
670            *
671            * <p>
672            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
673            * </p>
674            *
675            * @param threadId the thread ID
676            * @param start the lower bound of the range of message boards thread flags
677            * @param end the upper bound of the range of message boards thread flags (not inclusive)
678            * @return the range of matching message boards thread flags
679            */
680            public static List<MBThreadFlag> findByThreadId(long threadId, int start,
681                    int end) {
682                    return getPersistence().findByThreadId(threadId, start, end);
683            }
684    
685            /**
686            * Returns an ordered range of all the message boards thread flags where threadId = &#63;.
687            *
688            * <p>
689            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
690            * </p>
691            *
692            * @param threadId the thread ID
693            * @param start the lower bound of the range of message boards thread flags
694            * @param end the upper bound of the range of message boards thread flags (not inclusive)
695            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
696            * @return the ordered range of matching message boards thread flags
697            */
698            public static List<MBThreadFlag> findByThreadId(long threadId, int start,
699                    int end, OrderByComparator<MBThreadFlag> orderByComparator) {
700                    return getPersistence()
701                                       .findByThreadId(threadId, start, end, orderByComparator);
702            }
703    
704            /**
705            * Returns an ordered range of all the message boards thread flags where threadId = &#63;.
706            *
707            * <p>
708            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
709            * </p>
710            *
711            * @param threadId the thread ID
712            * @param start the lower bound of the range of message boards thread flags
713            * @param end the upper bound of the range of message boards thread flags (not inclusive)
714            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
715            * @param retrieveFromCache whether to retrieve from the finder cache
716            * @return the ordered range of matching message boards thread flags
717            */
718            public static List<MBThreadFlag> findByThreadId(long threadId, int start,
719                    int end, OrderByComparator<MBThreadFlag> orderByComparator,
720                    boolean retrieveFromCache) {
721                    return getPersistence()
722                                       .findByThreadId(threadId, start, end, orderByComparator,
723                            retrieveFromCache);
724            }
725    
726            /**
727            * Returns the first message boards thread flag in the ordered set where threadId = &#63;.
728            *
729            * @param threadId the thread ID
730            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
731            * @return the first matching message boards thread flag
732            * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found
733            */
734            public static MBThreadFlag findByThreadId_First(long threadId,
735                    OrderByComparator<MBThreadFlag> orderByComparator)
736                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
737                    return getPersistence().findByThreadId_First(threadId, orderByComparator);
738            }
739    
740            /**
741            * Returns the first message boards thread flag in the ordered set where threadId = &#63;.
742            *
743            * @param threadId the thread ID
744            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
745            * @return the first matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
746            */
747            public static MBThreadFlag fetchByThreadId_First(long threadId,
748                    OrderByComparator<MBThreadFlag> orderByComparator) {
749                    return getPersistence()
750                                       .fetchByThreadId_First(threadId, orderByComparator);
751            }
752    
753            /**
754            * Returns the last message boards thread flag in the ordered set where threadId = &#63;.
755            *
756            * @param threadId the thread ID
757            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
758            * @return the last matching message boards thread flag
759            * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found
760            */
761            public static MBThreadFlag findByThreadId_Last(long threadId,
762                    OrderByComparator<MBThreadFlag> orderByComparator)
763                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
764                    return getPersistence().findByThreadId_Last(threadId, orderByComparator);
765            }
766    
767            /**
768            * Returns the last message boards thread flag in the ordered set where threadId = &#63;.
769            *
770            * @param threadId the thread ID
771            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
772            * @return the last matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
773            */
774            public static MBThreadFlag fetchByThreadId_Last(long threadId,
775                    OrderByComparator<MBThreadFlag> orderByComparator) {
776                    return getPersistence().fetchByThreadId_Last(threadId, orderByComparator);
777            }
778    
779            /**
780            * Returns the message boards thread flags before and after the current message boards thread flag in the ordered set where threadId = &#63;.
781            *
782            * @param threadFlagId the primary key of the current message boards thread flag
783            * @param threadId the thread ID
784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
785            * @return the previous, current, and next message boards thread flag
786            * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
787            */
788            public static MBThreadFlag[] findByThreadId_PrevAndNext(long threadFlagId,
789                    long threadId, OrderByComparator<MBThreadFlag> orderByComparator)
790                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
791                    return getPersistence()
792                                       .findByThreadId_PrevAndNext(threadFlagId, threadId,
793                            orderByComparator);
794            }
795    
796            /**
797            * Removes all the message boards thread flags where threadId = &#63; from the database.
798            *
799            * @param threadId the thread ID
800            */
801            public static void removeByThreadId(long threadId) {
802                    getPersistence().removeByThreadId(threadId);
803            }
804    
805            /**
806            * Returns the number of message boards thread flags where threadId = &#63;.
807            *
808            * @param threadId the thread ID
809            * @return the number of matching message boards thread flags
810            */
811            public static int countByThreadId(long threadId) {
812                    return getPersistence().countByThreadId(threadId);
813            }
814    
815            /**
816            * Returns the message boards thread flag where userId = &#63; and threadId = &#63; or throws a {@link NoSuchThreadFlagException} if it could not be found.
817            *
818            * @param userId the user ID
819            * @param threadId the thread ID
820            * @return the matching message boards thread flag
821            * @throws NoSuchThreadFlagException if a matching message boards thread flag could not be found
822            */
823            public static MBThreadFlag findByU_T(long userId, long threadId)
824                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
825                    return getPersistence().findByU_T(userId, threadId);
826            }
827    
828            /**
829            * 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.
830            *
831            * @param userId the user ID
832            * @param threadId the thread ID
833            * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
834            */
835            public static MBThreadFlag fetchByU_T(long userId, long threadId) {
836                    return getPersistence().fetchByU_T(userId, threadId);
837            }
838    
839            /**
840            * 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.
841            *
842            * @param userId the user ID
843            * @param threadId the thread ID
844            * @param retrieveFromCache whether to retrieve from the finder cache
845            * @return the matching message boards thread flag, or <code>null</code> if a matching message boards thread flag could not be found
846            */
847            public static MBThreadFlag fetchByU_T(long userId, long threadId,
848                    boolean retrieveFromCache) {
849                    return getPersistence().fetchByU_T(userId, threadId, retrieveFromCache);
850            }
851    
852            /**
853            * Removes the message boards thread flag where userId = &#63; and threadId = &#63; from the database.
854            *
855            * @param userId the user ID
856            * @param threadId the thread ID
857            * @return the message boards thread flag that was removed
858            */
859            public static MBThreadFlag removeByU_T(long userId, long threadId)
860                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
861                    return getPersistence().removeByU_T(userId, threadId);
862            }
863    
864            /**
865            * Returns the number of message boards thread flags where userId = &#63; and threadId = &#63;.
866            *
867            * @param userId the user ID
868            * @param threadId the thread ID
869            * @return the number of matching message boards thread flags
870            */
871            public static int countByU_T(long userId, long threadId) {
872                    return getPersistence().countByU_T(userId, threadId);
873            }
874    
875            /**
876            * Caches the message boards thread flag in the entity cache if it is enabled.
877            *
878            * @param mbThreadFlag the message boards thread flag
879            */
880            public static void cacheResult(MBThreadFlag mbThreadFlag) {
881                    getPersistence().cacheResult(mbThreadFlag);
882            }
883    
884            /**
885            * Caches the message boards thread flags in the entity cache if it is enabled.
886            *
887            * @param mbThreadFlags the message boards thread flags
888            */
889            public static void cacheResult(List<MBThreadFlag> mbThreadFlags) {
890                    getPersistence().cacheResult(mbThreadFlags);
891            }
892    
893            /**
894            * Creates a new message boards thread flag with the primary key. Does not add the message boards thread flag to the database.
895            *
896            * @param threadFlagId the primary key for the new message boards thread flag
897            * @return the new message boards thread flag
898            */
899            public static MBThreadFlag create(long threadFlagId) {
900                    return getPersistence().create(threadFlagId);
901            }
902    
903            /**
904            * Removes the message boards thread flag with the primary key from the database. Also notifies the appropriate model listeners.
905            *
906            * @param threadFlagId the primary key of the message boards thread flag
907            * @return the message boards thread flag that was removed
908            * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
909            */
910            public static MBThreadFlag remove(long threadFlagId)
911                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
912                    return getPersistence().remove(threadFlagId);
913            }
914    
915            public static MBThreadFlag updateImpl(MBThreadFlag mbThreadFlag) {
916                    return getPersistence().updateImpl(mbThreadFlag);
917            }
918    
919            /**
920            * Returns the message boards thread flag with the primary key or throws a {@link NoSuchThreadFlagException} if it could not be found.
921            *
922            * @param threadFlagId the primary key of the message boards thread flag
923            * @return the message boards thread flag
924            * @throws NoSuchThreadFlagException if a message boards thread flag with the primary key could not be found
925            */
926            public static MBThreadFlag findByPrimaryKey(long threadFlagId)
927                    throws com.liferay.portlet.messageboards.exception.NoSuchThreadFlagException {
928                    return getPersistence().findByPrimaryKey(threadFlagId);
929            }
930    
931            /**
932            * Returns the message boards thread flag with the primary key or returns <code>null</code> if it could not be found.
933            *
934            * @param threadFlagId the primary key of the message boards thread flag
935            * @return the message boards thread flag, or <code>null</code> if a message boards thread flag with the primary key could not be found
936            */
937            public static MBThreadFlag fetchByPrimaryKey(long threadFlagId) {
938                    return getPersistence().fetchByPrimaryKey(threadFlagId);
939            }
940    
941            public static java.util.Map<java.io.Serializable, MBThreadFlag> fetchByPrimaryKeys(
942                    java.util.Set<java.io.Serializable> primaryKeys) {
943                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
944            }
945    
946            /**
947            * Returns all the message boards thread flags.
948            *
949            * @return the message boards thread flags
950            */
951            public static List<MBThreadFlag> findAll() {
952                    return getPersistence().findAll();
953            }
954    
955            /**
956            * Returns a range of all the message boards thread flags.
957            *
958            * <p>
959            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
960            * </p>
961            *
962            * @param start the lower bound of the range of message boards thread flags
963            * @param end the upper bound of the range of message boards thread flags (not inclusive)
964            * @return the range of message boards thread flags
965            */
966            public static List<MBThreadFlag> findAll(int start, int end) {
967                    return getPersistence().findAll(start, end);
968            }
969    
970            /**
971            * Returns an ordered range of all the message boards thread flags.
972            *
973            * <p>
974            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
975            * </p>
976            *
977            * @param start the lower bound of the range of message boards thread flags
978            * @param end the upper bound of the range of message boards thread flags (not inclusive)
979            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
980            * @return the ordered range of message boards thread flags
981            */
982            public static List<MBThreadFlag> findAll(int start, int end,
983                    OrderByComparator<MBThreadFlag> orderByComparator) {
984                    return getPersistence().findAll(start, end, orderByComparator);
985            }
986    
987            /**
988            * Returns an ordered range of all the message boards thread flags.
989            *
990            * <p>
991            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
992            * </p>
993            *
994            * @param start the lower bound of the range of message boards thread flags
995            * @param end the upper bound of the range of message boards thread flags (not inclusive)
996            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
997            * @param retrieveFromCache whether to retrieve from the finder cache
998            * @return the ordered range of message boards thread flags
999            */
1000            public static List<MBThreadFlag> findAll(int start, int end,
1001                    OrderByComparator<MBThreadFlag> orderByComparator,
1002                    boolean retrieveFromCache) {
1003                    return getPersistence()
1004                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1005            }
1006    
1007            /**
1008            * Removes all the message boards thread flags from the database.
1009            */
1010            public static void removeAll() {
1011                    getPersistence().removeAll();
1012            }
1013    
1014            /**
1015            * Returns the number of message boards thread flags.
1016            *
1017            * @return the number of message boards thread flags
1018            */
1019            public static int countAll() {
1020                    return getPersistence().countAll();
1021            }
1022    
1023            public static java.util.Set<java.lang.String> getBadColumnNames() {
1024                    return getPersistence().getBadColumnNames();
1025            }
1026    
1027            public static MBThreadFlagPersistence getPersistence() {
1028                    if (_persistence == null) {
1029                            _persistence = (MBThreadFlagPersistence)PortalBeanLocatorUtil.locate(MBThreadFlagPersistence.class.getName());
1030    
1031                            ReferenceRegistry.registerReference(MBThreadFlagUtil.class,
1032                                    "_persistence");
1033                    }
1034    
1035                    return _persistence;
1036            }
1037    
1038            private static MBThreadFlagPersistence _persistence;
1039    }