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