001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.messageboards.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.service.ServiceContext;
022    
023    import com.liferay.portlet.messageboards.model.MBThread;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the message boards thread service. This utility wraps {@link MBThreadPersistenceImpl} 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.
029     *
030     * <p>
031     * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
032     * </p>
033     *
034     * <p>
035     * Caching information and settings can be found in <code>portal.properties</code>
036     * </p>
037     *
038     * @author Brian Wing Shun Chan
039     * @see MBThreadPersistence
040     * @see MBThreadPersistenceImpl
041     * @generated
042     */
043    public class MBThreadUtil {
044            /**
045             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
046             */
047            public static void clearCache() {
048                    getPersistence().clearCache();
049            }
050    
051            /**
052             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
053             */
054            public static void clearCache(MBThread mbThread) {
055                    getPersistence().clearCache(mbThread);
056            }
057    
058            /**
059             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
060             */
061            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
062                    throws SystemException {
063                    return getPersistence().countWithDynamicQuery(dynamicQuery);
064            }
065    
066            /**
067             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
068             */
069            public static List<MBThread> findWithDynamicQuery(DynamicQuery dynamicQuery)
070                    throws SystemException {
071                    return getPersistence().findWithDynamicQuery(dynamicQuery);
072            }
073    
074            /**
075             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
076             */
077            public static List<MBThread> findWithDynamicQuery(
078                    DynamicQuery dynamicQuery, int start, int end)
079                    throws SystemException {
080                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
081            }
082    
083            /**
084             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
085             */
086            public static List<MBThread> findWithDynamicQuery(
087                    DynamicQuery dynamicQuery, int start, int end,
088                    OrderByComparator orderByComparator) throws SystemException {
089                    return getPersistence()
090                                       .findWithDynamicQuery(dynamicQuery, start, end,
091                            orderByComparator);
092            }
093    
094            /**
095             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
096             */
097            public static MBThread remove(MBThread mbThread) throws SystemException {
098                    return getPersistence().remove(mbThread);
099            }
100    
101            /**
102             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
103             */
104            public static MBThread update(MBThread mbThread, boolean merge)
105                    throws SystemException {
106                    return getPersistence().update(mbThread, merge);
107            }
108    
109            /**
110             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
111             */
112            public static MBThread update(MBThread mbThread, boolean merge,
113                    ServiceContext serviceContext) throws SystemException {
114                    return getPersistence().update(mbThread, merge, serviceContext);
115            }
116    
117            /**
118            * Caches the message boards thread in the entity cache if it is enabled.
119            *
120            * @param mbThread the message boards thread to cache
121            */
122            public static void cacheResult(
123                    com.liferay.portlet.messageboards.model.MBThread mbThread) {
124                    getPersistence().cacheResult(mbThread);
125            }
126    
127            /**
128            * Caches the message boards threads in the entity cache if it is enabled.
129            *
130            * @param mbThreads the message boards threads to cache
131            */
132            public static void cacheResult(
133                    java.util.List<com.liferay.portlet.messageboards.model.MBThread> mbThreads) {
134                    getPersistence().cacheResult(mbThreads);
135            }
136    
137            /**
138            * Creates a new message boards thread with the primary key. Does not add the message boards thread to the database.
139            *
140            * @param threadId the primary key for the new message boards thread
141            * @return the new message boards thread
142            */
143            public static com.liferay.portlet.messageboards.model.MBThread create(
144                    long threadId) {
145                    return getPersistence().create(threadId);
146            }
147    
148            /**
149            * Removes the message boards thread with the primary key from the database. Also notifies the appropriate model listeners.
150            *
151            * @param threadId the primary key of the message boards thread to remove
152            * @return the message boards thread that was removed
153            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
154            * @throws SystemException if a system exception occurred
155            */
156            public static com.liferay.portlet.messageboards.model.MBThread remove(
157                    long threadId)
158                    throws com.liferay.portal.kernel.exception.SystemException,
159                            com.liferay.portlet.messageboards.NoSuchThreadException {
160                    return getPersistence().remove(threadId);
161            }
162    
163            public static com.liferay.portlet.messageboards.model.MBThread updateImpl(
164                    com.liferay.portlet.messageboards.model.MBThread mbThread, boolean merge)
165                    throws com.liferay.portal.kernel.exception.SystemException {
166                    return getPersistence().updateImpl(mbThread, merge);
167            }
168    
169            /**
170            * Finds the message boards thread with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found.
171            *
172            * @param threadId the primary key of the message boards thread to find
173            * @return the message boards thread
174            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
175            * @throws SystemException if a system exception occurred
176            */
177            public static com.liferay.portlet.messageboards.model.MBThread findByPrimaryKey(
178                    long threadId)
179                    throws com.liferay.portal.kernel.exception.SystemException,
180                            com.liferay.portlet.messageboards.NoSuchThreadException {
181                    return getPersistence().findByPrimaryKey(threadId);
182            }
183    
184            /**
185            * Finds the message boards thread with the primary key or returns <code>null</code> if it could not be found.
186            *
187            * @param threadId the primary key of the message boards thread to find
188            * @return the message boards thread, or <code>null</code> if a message boards thread with the primary key could not be found
189            * @throws SystemException if a system exception occurred
190            */
191            public static com.liferay.portlet.messageboards.model.MBThread fetchByPrimaryKey(
192                    long threadId)
193                    throws com.liferay.portal.kernel.exception.SystemException {
194                    return getPersistence().fetchByPrimaryKey(threadId);
195            }
196    
197            /**
198            * Finds all the message boards threads where groupId = &#63;.
199            *
200            * @param groupId the group id to search with
201            * @return the matching message boards threads
202            * @throws SystemException if a system exception occurred
203            */
204            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId(
205                    long groupId)
206                    throws com.liferay.portal.kernel.exception.SystemException {
207                    return getPersistence().findByGroupId(groupId);
208            }
209    
210            /**
211            * Finds a range of all the message boards threads where groupId = &#63;.
212            *
213            * <p>
214            * 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.
215            * </p>
216            *
217            * @param groupId the group id to search with
218            * @param start the lower bound of the range of message boards threads to return
219            * @param end the upper bound of the range of message boards threads to return (not inclusive)
220            * @return the range of matching message boards threads
221            * @throws SystemException if a system exception occurred
222            */
223            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId(
224                    long groupId, int start, int end)
225                    throws com.liferay.portal.kernel.exception.SystemException {
226                    return getPersistence().findByGroupId(groupId, start, end);
227            }
228    
229            /**
230            * Finds an ordered range of all the message boards threads where groupId = &#63;.
231            *
232            * <p>
233            * 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.
234            * </p>
235            *
236            * @param groupId the group id to search with
237            * @param start the lower bound of the range of message boards threads to return
238            * @param end the upper bound of the range of message boards threads to return (not inclusive)
239            * @param orderByComparator the comparator to order the results by
240            * @return the ordered range of matching message boards threads
241            * @throws SystemException if a system exception occurred
242            */
243            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId(
244                    long groupId, int start, int end,
245                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
246                    throws com.liferay.portal.kernel.exception.SystemException {
247                    return getPersistence()
248                                       .findByGroupId(groupId, start, end, orderByComparator);
249            }
250    
251            /**
252            * Finds the first message boards thread in the ordered set where groupId = &#63;.
253            *
254            * <p>
255            * 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.
256            * </p>
257            *
258            * @param groupId the group id to search with
259            * @param orderByComparator the comparator to order the set by
260            * @return the first matching message boards thread
261            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
262            * @throws SystemException if a system exception occurred
263            */
264            public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_First(
265                    long groupId,
266                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
267                    throws com.liferay.portal.kernel.exception.SystemException,
268                            com.liferay.portlet.messageboards.NoSuchThreadException {
269                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
270            }
271    
272            /**
273            * Finds the last message boards thread in the ordered set where groupId = &#63;.
274            *
275            * <p>
276            * 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.
277            * </p>
278            *
279            * @param groupId the group id to search with
280            * @param orderByComparator the comparator to order the set by
281            * @return the last matching message boards thread
282            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
283            * @throws SystemException if a system exception occurred
284            */
285            public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_Last(
286                    long groupId,
287                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
288                    throws com.liferay.portal.kernel.exception.SystemException,
289                            com.liferay.portlet.messageboards.NoSuchThreadException {
290                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
291            }
292    
293            /**
294            * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63;.
295            *
296            * <p>
297            * 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.
298            * </p>
299            *
300            * @param threadId the primary key of the current message boards thread
301            * @param groupId the group id to search with
302            * @param orderByComparator the comparator to order the set by
303            * @return the previous, current, and next message boards thread
304            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
305            * @throws SystemException if a system exception occurred
306            */
307            public static com.liferay.portlet.messageboards.model.MBThread[] findByGroupId_PrevAndNext(
308                    long threadId, long groupId,
309                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
310                    throws com.liferay.portal.kernel.exception.SystemException,
311                            com.liferay.portlet.messageboards.NoSuchThreadException {
312                    return getPersistence()
313                                       .findByGroupId_PrevAndNext(threadId, groupId,
314                            orderByComparator);
315            }
316    
317            /**
318            * Finds all the message boards threads where groupId = &#63; and categoryId = &#63;.
319            *
320            * @param groupId the group id to search with
321            * @param categoryId the category id to search with
322            * @return the matching message boards threads
323            * @throws SystemException if a system exception occurred
324            */
325            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
326                    long groupId, long categoryId)
327                    throws com.liferay.portal.kernel.exception.SystemException {
328                    return getPersistence().findByG_C(groupId, categoryId);
329            }
330    
331            /**
332            * Finds a range of all the message boards threads where groupId = &#63; and categoryId = &#63;.
333            *
334            * <p>
335            * 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.
336            * </p>
337            *
338            * @param groupId the group id to search with
339            * @param categoryId the category id to search with
340            * @param start the lower bound of the range of message boards threads to return
341            * @param end the upper bound of the range of message boards threads to return (not inclusive)
342            * @return the range of matching message boards threads
343            * @throws SystemException if a system exception occurred
344            */
345            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
346                    long groupId, long categoryId, int start, int end)
347                    throws com.liferay.portal.kernel.exception.SystemException {
348                    return getPersistence().findByG_C(groupId, categoryId, start, end);
349            }
350    
351            /**
352            * Finds an ordered range of all the message boards threads where groupId = &#63; and categoryId = &#63;.
353            *
354            * <p>
355            * 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.
356            * </p>
357            *
358            * @param groupId the group id to search with
359            * @param categoryId the category id to search with
360            * @param start the lower bound of the range of message boards threads to return
361            * @param end the upper bound of the range of message boards threads to return (not inclusive)
362            * @param orderByComparator the comparator to order the results by
363            * @return the ordered range of matching message boards threads
364            * @throws SystemException if a system exception occurred
365            */
366            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
367                    long groupId, long categoryId, int start, int end,
368                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
369                    throws com.liferay.portal.kernel.exception.SystemException {
370                    return getPersistence()
371                                       .findByG_C(groupId, categoryId, start, end, orderByComparator);
372            }
373    
374            /**
375            * Finds the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
376            *
377            * <p>
378            * 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.
379            * </p>
380            *
381            * @param groupId the group id to search with
382            * @param categoryId the category id to search with
383            * @param orderByComparator the comparator to order the set by
384            * @return the first matching message boards thread
385            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
386            * @throws SystemException if a system exception occurred
387            */
388            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_First(
389                    long groupId, long categoryId,
390                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
391                    throws com.liferay.portal.kernel.exception.SystemException,
392                            com.liferay.portlet.messageboards.NoSuchThreadException {
393                    return getPersistence()
394                                       .findByG_C_First(groupId, categoryId, orderByComparator);
395            }
396    
397            /**
398            * Finds the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
399            *
400            * <p>
401            * 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.
402            * </p>
403            *
404            * @param groupId the group id to search with
405            * @param categoryId the category id to search with
406            * @param orderByComparator the comparator to order the set by
407            * @return the last matching message boards thread
408            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
409            * @throws SystemException if a system exception occurred
410            */
411            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_Last(
412                    long groupId, long categoryId,
413                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
414                    throws com.liferay.portal.kernel.exception.SystemException,
415                            com.liferay.portlet.messageboards.NoSuchThreadException {
416                    return getPersistence()
417                                       .findByG_C_Last(groupId, categoryId, orderByComparator);
418            }
419    
420            /**
421            * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
422            *
423            * <p>
424            * 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.
425            * </p>
426            *
427            * @param threadId the primary key of the current message boards thread
428            * @param groupId the group id to search with
429            * @param categoryId the category id to search with
430            * @param orderByComparator the comparator to order the set by
431            * @return the previous, current, and next message boards thread
432            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
433            * @throws SystemException if a system exception occurred
434            */
435            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_PrevAndNext(
436                    long threadId, long groupId, long categoryId,
437                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
438                    throws com.liferay.portal.kernel.exception.SystemException,
439                            com.liferay.portlet.messageboards.NoSuchThreadException {
440                    return getPersistence()
441                                       .findByG_C_PrevAndNext(threadId, groupId, categoryId,
442                            orderByComparator);
443            }
444    
445            /**
446            * Finds all the message boards threads where groupId = &#63; and categoryId = any &#63;.
447            *
448            * <p>
449            * 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.
450            * </p>
451            *
452            * @param groupId the group id to search with
453            * @param categoryIds the category ids to search with
454            * @return the matching message boards threads
455            * @throws SystemException if a system exception occurred
456            */
457            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
458                    long groupId, long[] categoryIds)
459                    throws com.liferay.portal.kernel.exception.SystemException {
460                    return getPersistence().findByG_C(groupId, categoryIds);
461            }
462    
463            /**
464            * Finds a range of all the message boards threads where groupId = &#63; and categoryId = any &#63;.
465            *
466            * <p>
467            * 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.
468            * </p>
469            *
470            * @param groupId the group id to search with
471            * @param categoryIds the category ids to search with
472            * @param start the lower bound of the range of message boards threads to return
473            * @param end the upper bound of the range of message boards threads to return (not inclusive)
474            * @return the range of matching message boards threads
475            * @throws SystemException if a system exception occurred
476            */
477            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
478                    long groupId, long[] categoryIds, int start, int end)
479                    throws com.liferay.portal.kernel.exception.SystemException {
480                    return getPersistence().findByG_C(groupId, categoryIds, start, end);
481            }
482    
483            /**
484            * Finds an ordered range of all the message boards threads where groupId = &#63; and categoryId = any &#63;.
485            *
486            * <p>
487            * 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.
488            * </p>
489            *
490            * @param groupId the group id to search with
491            * @param categoryIds the category ids to search with
492            * @param start the lower bound of the range of message boards threads to return
493            * @param end the upper bound of the range of message boards threads to return (not inclusive)
494            * @param orderByComparator the comparator to order the results by
495            * @return the ordered range of matching message boards threads
496            * @throws SystemException if a system exception occurred
497            */
498            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
499                    long groupId, long[] categoryIds, int start, int end,
500                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
501                    throws com.liferay.portal.kernel.exception.SystemException {
502                    return getPersistence()
503                                       .findByG_C(groupId, categoryIds, start, end,
504                            orderByComparator);
505            }
506    
507            /**
508            * Finds all the message boards threads where groupId = &#63; and categoryId &ne; &#63;.
509            *
510            * @param groupId the group id to search with
511            * @param categoryId the category id to search with
512            * @return the matching message boards threads
513            * @throws SystemException if a system exception occurred
514            */
515            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC(
516                    long groupId, long categoryId)
517                    throws com.liferay.portal.kernel.exception.SystemException {
518                    return getPersistence().findByG_NotC(groupId, categoryId);
519            }
520    
521            /**
522            * Finds a range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63;.
523            *
524            * <p>
525            * 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.
526            * </p>
527            *
528            * @param groupId the group id to search with
529            * @param categoryId the category id to search with
530            * @param start the lower bound of the range of message boards threads to return
531            * @param end the upper bound of the range of message boards threads to return (not inclusive)
532            * @return the range of matching message boards threads
533            * @throws SystemException if a system exception occurred
534            */
535            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC(
536                    long groupId, long categoryId, int start, int end)
537                    throws com.liferay.portal.kernel.exception.SystemException {
538                    return getPersistence().findByG_NotC(groupId, categoryId, start, end);
539            }
540    
541            /**
542            * Finds an ordered range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63;.
543            *
544            * <p>
545            * 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.
546            * </p>
547            *
548            * @param groupId the group id to search with
549            * @param categoryId the category id to search with
550            * @param start the lower bound of the range of message boards threads to return
551            * @param end the upper bound of the range of message boards threads to return (not inclusive)
552            * @param orderByComparator the comparator to order the results by
553            * @return the ordered range of matching message boards threads
554            * @throws SystemException if a system exception occurred
555            */
556            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC(
557                    long groupId, long categoryId, int start, int end,
558                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
559                    throws com.liferay.portal.kernel.exception.SystemException {
560                    return getPersistence()
561                                       .findByG_NotC(groupId, categoryId, start, end,
562                            orderByComparator);
563            }
564    
565            /**
566            * Finds the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
567            *
568            * <p>
569            * 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.
570            * </p>
571            *
572            * @param groupId the group id to search with
573            * @param categoryId the category id to search with
574            * @param orderByComparator the comparator to order the set by
575            * @return the first matching message boards thread
576            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
577            * @throws SystemException if a system exception occurred
578            */
579            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_First(
580                    long groupId, long categoryId,
581                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
582                    throws com.liferay.portal.kernel.exception.SystemException,
583                            com.liferay.portlet.messageboards.NoSuchThreadException {
584                    return getPersistence()
585                                       .findByG_NotC_First(groupId, categoryId, orderByComparator);
586            }
587    
588            /**
589            * Finds the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
590            *
591            * <p>
592            * 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.
593            * </p>
594            *
595            * @param groupId the group id to search with
596            * @param categoryId the category id to search with
597            * @param orderByComparator the comparator to order the set by
598            * @return the last matching message boards thread
599            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
600            * @throws SystemException if a system exception occurred
601            */
602            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_Last(
603                    long groupId, long categoryId,
604                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
605                    throws com.liferay.portal.kernel.exception.SystemException,
606                            com.liferay.portlet.messageboards.NoSuchThreadException {
607                    return getPersistence()
608                                       .findByG_NotC_Last(groupId, categoryId, orderByComparator);
609            }
610    
611            /**
612            * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
613            *
614            * <p>
615            * 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.
616            * </p>
617            *
618            * @param threadId the primary key of the current message boards thread
619            * @param groupId the group id to search with
620            * @param categoryId the category id to search with
621            * @param orderByComparator the comparator to order the set by
622            * @return the previous, current, and next message boards thread
623            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
624            * @throws SystemException if a system exception occurred
625            */
626            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_PrevAndNext(
627                    long threadId, long groupId, long categoryId,
628                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
629                    throws com.liferay.portal.kernel.exception.SystemException,
630                            com.liferay.portlet.messageboards.NoSuchThreadException {
631                    return getPersistence()
632                                       .findByG_NotC_PrevAndNext(threadId, groupId, categoryId,
633                            orderByComparator);
634            }
635    
636            /**
637            * Finds all the message boards threads where groupId = &#63; and status = &#63;.
638            *
639            * @param groupId the group id to search with
640            * @param status the status to search with
641            * @return the matching message boards threads
642            * @throws SystemException if a system exception occurred
643            */
644            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S(
645                    long groupId, int status)
646                    throws com.liferay.portal.kernel.exception.SystemException {
647                    return getPersistence().findByG_S(groupId, status);
648            }
649    
650            /**
651            * Finds a range of all the message boards threads where groupId = &#63; and status = &#63;.
652            *
653            * <p>
654            * 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.
655            * </p>
656            *
657            * @param groupId the group id to search with
658            * @param status the status to search with
659            * @param start the lower bound of the range of message boards threads to return
660            * @param end the upper bound of the range of message boards threads to return (not inclusive)
661            * @return the range of matching message boards threads
662            * @throws SystemException if a system exception occurred
663            */
664            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S(
665                    long groupId, int status, int start, int end)
666                    throws com.liferay.portal.kernel.exception.SystemException {
667                    return getPersistence().findByG_S(groupId, status, start, end);
668            }
669    
670            /**
671            * Finds an ordered range of all the message boards threads where groupId = &#63; and status = &#63;.
672            *
673            * <p>
674            * 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.
675            * </p>
676            *
677            * @param groupId the group id to search with
678            * @param status the status to search with
679            * @param start the lower bound of the range of message boards threads to return
680            * @param end the upper bound of the range of message boards threads to return (not inclusive)
681            * @param orderByComparator the comparator to order the results by
682            * @return the ordered range of matching message boards threads
683            * @throws SystemException if a system exception occurred
684            */
685            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S(
686                    long groupId, int status, int start, int end,
687                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
688                    throws com.liferay.portal.kernel.exception.SystemException {
689                    return getPersistence()
690                                       .findByG_S(groupId, status, start, end, orderByComparator);
691            }
692    
693            /**
694            * Finds the first message boards thread in the ordered set where groupId = &#63; and status = &#63;.
695            *
696            * <p>
697            * 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.
698            * </p>
699            *
700            * @param groupId the group id to search with
701            * @param status the status to search with
702            * @param orderByComparator the comparator to order the set by
703            * @return the first matching message boards thread
704            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
705            * @throws SystemException if a system exception occurred
706            */
707            public static com.liferay.portlet.messageboards.model.MBThread findByG_S_First(
708                    long groupId, int status,
709                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
710                    throws com.liferay.portal.kernel.exception.SystemException,
711                            com.liferay.portlet.messageboards.NoSuchThreadException {
712                    return getPersistence()
713                                       .findByG_S_First(groupId, status, orderByComparator);
714            }
715    
716            /**
717            * Finds the last message boards thread in the ordered set where groupId = &#63; and status = &#63;.
718            *
719            * <p>
720            * 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.
721            * </p>
722            *
723            * @param groupId the group id to search with
724            * @param status the status to search with
725            * @param orderByComparator the comparator to order the set by
726            * @return the last matching message boards thread
727            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
728            * @throws SystemException if a system exception occurred
729            */
730            public static com.liferay.portlet.messageboards.model.MBThread findByG_S_Last(
731                    long groupId, int status,
732                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
733                    throws com.liferay.portal.kernel.exception.SystemException,
734                            com.liferay.portlet.messageboards.NoSuchThreadException {
735                    return getPersistence()
736                                       .findByG_S_Last(groupId, status, orderByComparator);
737            }
738    
739            /**
740            * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and status = &#63;.
741            *
742            * <p>
743            * 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.
744            * </p>
745            *
746            * @param threadId the primary key of the current message boards thread
747            * @param groupId the group id to search with
748            * @param status the status to search with
749            * @param orderByComparator the comparator to order the set by
750            * @return the previous, current, and next message boards thread
751            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
752            * @throws SystemException if a system exception occurred
753            */
754            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_S_PrevAndNext(
755                    long threadId, long groupId, int status,
756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
757                    throws com.liferay.portal.kernel.exception.SystemException,
758                            com.liferay.portlet.messageboards.NoSuchThreadException {
759                    return getPersistence()
760                                       .findByG_S_PrevAndNext(threadId, groupId, status,
761                            orderByComparator);
762            }
763    
764            /**
765            * Finds all the message boards threads where categoryId = &#63; and priority = &#63;.
766            *
767            * @param categoryId the category id to search with
768            * @param priority the priority to search with
769            * @return the matching message boards threads
770            * @throws SystemException if a system exception occurred
771            */
772            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P(
773                    long categoryId, double priority)
774                    throws com.liferay.portal.kernel.exception.SystemException {
775                    return getPersistence().findByC_P(categoryId, priority);
776            }
777    
778            /**
779            * Finds a range of all the message boards threads where categoryId = &#63; and priority = &#63;.
780            *
781            * <p>
782            * 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.
783            * </p>
784            *
785            * @param categoryId the category id to search with
786            * @param priority the priority to search with
787            * @param start the lower bound of the range of message boards threads to return
788            * @param end the upper bound of the range of message boards threads to return (not inclusive)
789            * @return the range of matching message boards threads
790            * @throws SystemException if a system exception occurred
791            */
792            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P(
793                    long categoryId, double priority, int start, int end)
794                    throws com.liferay.portal.kernel.exception.SystemException {
795                    return getPersistence().findByC_P(categoryId, priority, start, end);
796            }
797    
798            /**
799            * Finds an ordered range of all the message boards threads where categoryId = &#63; and priority = &#63;.
800            *
801            * <p>
802            * 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.
803            * </p>
804            *
805            * @param categoryId the category id to search with
806            * @param priority the priority to search with
807            * @param start the lower bound of the range of message boards threads to return
808            * @param end the upper bound of the range of message boards threads to return (not inclusive)
809            * @param orderByComparator the comparator to order the results by
810            * @return the ordered range of matching message boards threads
811            * @throws SystemException if a system exception occurred
812            */
813            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P(
814                    long categoryId, double priority, int start, int end,
815                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
816                    throws com.liferay.portal.kernel.exception.SystemException {
817                    return getPersistence()
818                                       .findByC_P(categoryId, priority, start, end,
819                            orderByComparator);
820            }
821    
822            /**
823            * Finds the first message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
824            *
825            * <p>
826            * 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.
827            * </p>
828            *
829            * @param categoryId the category id to search with
830            * @param priority the priority to search with
831            * @param orderByComparator the comparator to order the set by
832            * @return the first matching message boards thread
833            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
834            * @throws SystemException if a system exception occurred
835            */
836            public static com.liferay.portlet.messageboards.model.MBThread findByC_P_First(
837                    long categoryId, double priority,
838                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
839                    throws com.liferay.portal.kernel.exception.SystemException,
840                            com.liferay.portlet.messageboards.NoSuchThreadException {
841                    return getPersistence()
842                                       .findByC_P_First(categoryId, priority, orderByComparator);
843            }
844    
845            /**
846            * Finds the last message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
847            *
848            * <p>
849            * 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.
850            * </p>
851            *
852            * @param categoryId the category id to search with
853            * @param priority the priority to search with
854            * @param orderByComparator the comparator to order the set by
855            * @return the last matching message boards thread
856            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
857            * @throws SystemException if a system exception occurred
858            */
859            public static com.liferay.portlet.messageboards.model.MBThread findByC_P_Last(
860                    long categoryId, double priority,
861                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
862                    throws com.liferay.portal.kernel.exception.SystemException,
863                            com.liferay.portlet.messageboards.NoSuchThreadException {
864                    return getPersistence()
865                                       .findByC_P_Last(categoryId, priority, orderByComparator);
866            }
867    
868            /**
869            * Finds the message boards threads before and after the current message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
870            *
871            * <p>
872            * 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.
873            * </p>
874            *
875            * @param threadId the primary key of the current message boards thread
876            * @param categoryId the category id to search with
877            * @param priority the priority to search with
878            * @param orderByComparator the comparator to order the set by
879            * @return the previous, current, and next message boards thread
880            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
881            * @throws SystemException if a system exception occurred
882            */
883            public static com.liferay.portlet.messageboards.model.MBThread[] findByC_P_PrevAndNext(
884                    long threadId, long categoryId, double priority,
885                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
886                    throws com.liferay.portal.kernel.exception.SystemException,
887                            com.liferay.portlet.messageboards.NoSuchThreadException {
888                    return getPersistence()
889                                       .findByC_P_PrevAndNext(threadId, categoryId, priority,
890                            orderByComparator);
891            }
892    
893            /**
894            * Finds all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
895            *
896            * @param groupId the group id to search with
897            * @param categoryId the category id to search with
898            * @param lastPostDate the last post date to search with
899            * @return the matching message boards threads
900            * @throws SystemException if a system exception occurred
901            */
902            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L(
903                    long groupId, long categoryId, java.util.Date lastPostDate)
904                    throws com.liferay.portal.kernel.exception.SystemException {
905                    return getPersistence().findByG_C_L(groupId, categoryId, lastPostDate);
906            }
907    
908            /**
909            * Finds a range of all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
910            *
911            * <p>
912            * 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.
913            * </p>
914            *
915            * @param groupId the group id to search with
916            * @param categoryId the category id to search with
917            * @param lastPostDate the last post date to search with
918            * @param start the lower bound of the range of message boards threads to return
919            * @param end the upper bound of the range of message boards threads to return (not inclusive)
920            * @return the range of matching message boards threads
921            * @throws SystemException if a system exception occurred
922            */
923            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L(
924                    long groupId, long categoryId, java.util.Date lastPostDate, int start,
925                    int end) throws com.liferay.portal.kernel.exception.SystemException {
926                    return getPersistence()
927                                       .findByG_C_L(groupId, categoryId, lastPostDate, start, end);
928            }
929    
930            /**
931            * Finds an ordered range of all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
932            *
933            * <p>
934            * 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.
935            * </p>
936            *
937            * @param groupId the group id to search with
938            * @param categoryId the category id to search with
939            * @param lastPostDate the last post date to search with
940            * @param start the lower bound of the range of message boards threads to return
941            * @param end the upper bound of the range of message boards threads to return (not inclusive)
942            * @param orderByComparator the comparator to order the results by
943            * @return the ordered range of matching message boards threads
944            * @throws SystemException if a system exception occurred
945            */
946            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L(
947                    long groupId, long categoryId, java.util.Date lastPostDate, int start,
948                    int end,
949                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
950                    throws com.liferay.portal.kernel.exception.SystemException {
951                    return getPersistence()
952                                       .findByG_C_L(groupId, categoryId, lastPostDate, start, end,
953                            orderByComparator);
954            }
955    
956            /**
957            * Finds the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
958            *
959            * <p>
960            * 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.
961            * </p>
962            *
963            * @param groupId the group id to search with
964            * @param categoryId the category id to search with
965            * @param lastPostDate the last post date to search with
966            * @param orderByComparator the comparator to order the set by
967            * @return the first matching message boards thread
968            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
969            * @throws SystemException if a system exception occurred
970            */
971            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_First(
972                    long groupId, long categoryId, java.util.Date lastPostDate,
973                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
974                    throws com.liferay.portal.kernel.exception.SystemException,
975                            com.liferay.portlet.messageboards.NoSuchThreadException {
976                    return getPersistence()
977                                       .findByG_C_L_First(groupId, categoryId, lastPostDate,
978                            orderByComparator);
979            }
980    
981            /**
982            * Finds the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
983            *
984            * <p>
985            * 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.
986            * </p>
987            *
988            * @param groupId the group id to search with
989            * @param categoryId the category id to search with
990            * @param lastPostDate the last post date to search with
991            * @param orderByComparator the comparator to order the set by
992            * @return the last matching message boards thread
993            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
994            * @throws SystemException if a system exception occurred
995            */
996            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_Last(
997                    long groupId, long categoryId, java.util.Date lastPostDate,
998                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
999                    throws com.liferay.portal.kernel.exception.SystemException,
1000                            com.liferay.portlet.messageboards.NoSuchThreadException {
1001                    return getPersistence()
1002                                       .findByG_C_L_Last(groupId, categoryId, lastPostDate,
1003                            orderByComparator);
1004            }
1005    
1006            /**
1007            * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1008            *
1009            * <p>
1010            * 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.
1011            * </p>
1012            *
1013            * @param threadId the primary key of the current message boards thread
1014            * @param groupId the group id to search with
1015            * @param categoryId the category id to search with
1016            * @param lastPostDate the last post date to search with
1017            * @param orderByComparator the comparator to order the set by
1018            * @return the previous, current, and next message boards thread
1019            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1020            * @throws SystemException if a system exception occurred
1021            */
1022            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_L_PrevAndNext(
1023                    long threadId, long groupId, long categoryId,
1024                    java.util.Date lastPostDate,
1025                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1026                    throws com.liferay.portal.kernel.exception.SystemException,
1027                            com.liferay.portlet.messageboards.NoSuchThreadException {
1028                    return getPersistence()
1029                                       .findByG_C_L_PrevAndNext(threadId, groupId, categoryId,
1030                            lastPostDate, orderByComparator);
1031            }
1032    
1033            /**
1034            * Finds all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
1035            *
1036            * @param groupId the group id to search with
1037            * @param categoryId the category id to search with
1038            * @param status the status to search with
1039            * @return the matching message boards threads
1040            * @throws SystemException if a system exception occurred
1041            */
1042            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
1043                    long groupId, long categoryId, int status)
1044                    throws com.liferay.portal.kernel.exception.SystemException {
1045                    return getPersistence().findByG_C_S(groupId, categoryId, status);
1046            }
1047    
1048            /**
1049            * Finds a range of all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
1050            *
1051            * <p>
1052            * 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.
1053            * </p>
1054            *
1055            * @param groupId the group id to search with
1056            * @param categoryId the category id to search with
1057            * @param status the status to search with
1058            * @param start the lower bound of the range of message boards threads to return
1059            * @param end the upper bound of the range of message boards threads to return (not inclusive)
1060            * @return the range of matching message boards threads
1061            * @throws SystemException if a system exception occurred
1062            */
1063            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
1064                    long groupId, long categoryId, int status, int start, int end)
1065                    throws com.liferay.portal.kernel.exception.SystemException {
1066                    return getPersistence()
1067                                       .findByG_C_S(groupId, categoryId, status, start, end);
1068            }
1069    
1070            /**
1071            * Finds an ordered range of all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
1072            *
1073            * <p>
1074            * 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.
1075            * </p>
1076            *
1077            * @param groupId the group id to search with
1078            * @param categoryId the category id to search with
1079            * @param status the status to search with
1080            * @param start the lower bound of the range of message boards threads to return
1081            * @param end the upper bound of the range of message boards threads to return (not inclusive)
1082            * @param orderByComparator the comparator to order the results by
1083            * @return the ordered range of matching message boards threads
1084            * @throws SystemException if a system exception occurred
1085            */
1086            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
1087                    long groupId, long categoryId, int status, int start, int end,
1088                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1089                    throws com.liferay.portal.kernel.exception.SystemException {
1090                    return getPersistence()
1091                                       .findByG_C_S(groupId, categoryId, status, start, end,
1092                            orderByComparator);
1093            }
1094    
1095            /**
1096            * Finds the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
1097            *
1098            * <p>
1099            * 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.
1100            * </p>
1101            *
1102            * @param groupId the group id to search with
1103            * @param categoryId the category id to search with
1104            * @param status the status to search with
1105            * @param orderByComparator the comparator to order the set by
1106            * @return the first matching message boards thread
1107            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1108            * @throws SystemException if a system exception occurred
1109            */
1110            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_First(
1111                    long groupId, long categoryId, int status,
1112                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1113                    throws com.liferay.portal.kernel.exception.SystemException,
1114                            com.liferay.portlet.messageboards.NoSuchThreadException {
1115                    return getPersistence()
1116                                       .findByG_C_S_First(groupId, categoryId, status,
1117                            orderByComparator);
1118            }
1119    
1120            /**
1121            * Finds the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
1122            *
1123            * <p>
1124            * 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.
1125            * </p>
1126            *
1127            * @param groupId the group id to search with
1128            * @param categoryId the category id to search with
1129            * @param status the status to search with
1130            * @param orderByComparator the comparator to order the set by
1131            * @return the last matching message boards thread
1132            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1133            * @throws SystemException if a system exception occurred
1134            */
1135            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_Last(
1136                    long groupId, long categoryId, int status,
1137                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1138                    throws com.liferay.portal.kernel.exception.SystemException,
1139                            com.liferay.portlet.messageboards.NoSuchThreadException {
1140                    return getPersistence()
1141                                       .findByG_C_S_Last(groupId, categoryId, status,
1142                            orderByComparator);
1143            }
1144    
1145            /**
1146            * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
1147            *
1148            * <p>
1149            * 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.
1150            * </p>
1151            *
1152            * @param threadId the primary key of the current message boards thread
1153            * @param groupId the group id to search with
1154            * @param categoryId the category id to search with
1155            * @param status the status to search with
1156            * @param orderByComparator the comparator to order the set by
1157            * @return the previous, current, and next message boards thread
1158            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1159            * @throws SystemException if a system exception occurred
1160            */
1161            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_S_PrevAndNext(
1162                    long threadId, long groupId, long categoryId, int status,
1163                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1164                    throws com.liferay.portal.kernel.exception.SystemException,
1165                            com.liferay.portlet.messageboards.NoSuchThreadException {
1166                    return getPersistence()
1167                                       .findByG_C_S_PrevAndNext(threadId, groupId, categoryId,
1168                            status, orderByComparator);
1169            }
1170    
1171            /**
1172            * Finds all the message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
1173            *
1174            * <p>
1175            * 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.
1176            * </p>
1177            *
1178            * @param groupId the group id to search with
1179            * @param categoryIds the category ids to search with
1180            * @param status the status to search with
1181            * @return the matching message boards threads
1182            * @throws SystemException if a system exception occurred
1183            */
1184            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
1185                    long groupId, long[] categoryIds, int status)
1186                    throws com.liferay.portal.kernel.exception.SystemException {
1187                    return getPersistence().findByG_C_S(groupId, categoryIds, status);
1188            }
1189    
1190            /**
1191            * Finds a range of all the message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
1192            *
1193            * <p>
1194            * 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.
1195            * </p>
1196            *
1197            * @param groupId the group id to search with
1198            * @param categoryIds the category ids to search with
1199            * @param status the status to search with
1200            * @param start the lower bound of the range of message boards threads to return
1201            * @param end the upper bound of the range of message boards threads to return (not inclusive)
1202            * @return the range of matching message boards threads
1203            * @throws SystemException if a system exception occurred
1204            */
1205            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
1206                    long groupId, long[] categoryIds, int status, int start, int end)
1207                    throws com.liferay.portal.kernel.exception.SystemException {
1208                    return getPersistence()
1209                                       .findByG_C_S(groupId, categoryIds, status, start, end);
1210            }
1211    
1212            /**
1213            * Finds an ordered range of all the message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
1214            *
1215            * <p>
1216            * 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.
1217            * </p>
1218            *
1219            * @param groupId the group id to search with
1220            * @param categoryIds the category ids to search with
1221            * @param status the status to search with
1222            * @param start the lower bound of the range of message boards threads to return
1223            * @param end the upper bound of the range of message boards threads to return (not inclusive)
1224            * @param orderByComparator the comparator to order the results by
1225            * @return the ordered range of matching message boards threads
1226            * @throws SystemException if a system exception occurred
1227            */
1228            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
1229                    long groupId, long[] categoryIds, int status, int start, int end,
1230                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1231                    throws com.liferay.portal.kernel.exception.SystemException {
1232                    return getPersistence()
1233                                       .findByG_C_S(groupId, categoryIds, status, start, end,
1234                            orderByComparator);
1235            }
1236    
1237            /**
1238            * Finds all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
1239            *
1240            * @param groupId the group id to search with
1241            * @param categoryId the category id to search with
1242            * @param status the status to search with
1243            * @return the matching message boards threads
1244            * @throws SystemException if a system exception occurred
1245            */
1246            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S(
1247                    long groupId, long categoryId, int status)
1248                    throws com.liferay.portal.kernel.exception.SystemException {
1249                    return getPersistence().findByG_NotC_S(groupId, categoryId, status);
1250            }
1251    
1252            /**
1253            * Finds a range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
1254            *
1255            * <p>
1256            * 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.
1257            * </p>
1258            *
1259            * @param groupId the group id to search with
1260            * @param categoryId the category id to search with
1261            * @param status the status to search with
1262            * @param start the lower bound of the range of message boards threads to return
1263            * @param end the upper bound of the range of message boards threads to return (not inclusive)
1264            * @return the range of matching message boards threads
1265            * @throws SystemException if a system exception occurred
1266            */
1267            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S(
1268                    long groupId, long categoryId, int status, int start, int end)
1269                    throws com.liferay.portal.kernel.exception.SystemException {
1270                    return getPersistence()
1271                                       .findByG_NotC_S(groupId, categoryId, status, start, end);
1272            }
1273    
1274            /**
1275            * Finds an ordered range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
1276            *
1277            * <p>
1278            * 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.
1279            * </p>
1280            *
1281            * @param groupId the group id to search with
1282            * @param categoryId the category id to search with
1283            * @param status the status to search with
1284            * @param start the lower bound of the range of message boards threads to return
1285            * @param end the upper bound of the range of message boards threads to return (not inclusive)
1286            * @param orderByComparator the comparator to order the results by
1287            * @return the ordered range of matching message boards threads
1288            * @throws SystemException if a system exception occurred
1289            */
1290            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S(
1291                    long groupId, long categoryId, int status, int start, int end,
1292                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1293                    throws com.liferay.portal.kernel.exception.SystemException {
1294                    return getPersistence()
1295                                       .findByG_NotC_S(groupId, categoryId, status, start, end,
1296                            orderByComparator);
1297            }
1298    
1299            /**
1300            * Finds the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
1301            *
1302            * <p>
1303            * 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.
1304            * </p>
1305            *
1306            * @param groupId the group id to search with
1307            * @param categoryId the category id to search with
1308            * @param status the status to search with
1309            * @param orderByComparator the comparator to order the set by
1310            * @return the first matching message boards thread
1311            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1312            * @throws SystemException if a system exception occurred
1313            */
1314            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_First(
1315                    long groupId, long categoryId, int status,
1316                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1317                    throws com.liferay.portal.kernel.exception.SystemException,
1318                            com.liferay.portlet.messageboards.NoSuchThreadException {
1319                    return getPersistence()
1320                                       .findByG_NotC_S_First(groupId, categoryId, status,
1321                            orderByComparator);
1322            }
1323    
1324            /**
1325            * Finds the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
1326            *
1327            * <p>
1328            * 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.
1329            * </p>
1330            *
1331            * @param groupId the group id to search with
1332            * @param categoryId the category id to search with
1333            * @param status the status to search with
1334            * @param orderByComparator the comparator to order the set by
1335            * @return the last matching message boards thread
1336            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1337            * @throws SystemException if a system exception occurred
1338            */
1339            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_Last(
1340                    long groupId, long categoryId, int status,
1341                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1342                    throws com.liferay.portal.kernel.exception.SystemException,
1343                            com.liferay.portlet.messageboards.NoSuchThreadException {
1344                    return getPersistence()
1345                                       .findByG_NotC_S_Last(groupId, categoryId, status,
1346                            orderByComparator);
1347            }
1348    
1349            /**
1350            * Finds the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
1351            *
1352            * <p>
1353            * 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.
1354            * </p>
1355            *
1356            * @param threadId the primary key of the current message boards thread
1357            * @param groupId the group id to search with
1358            * @param categoryId the category id to search with
1359            * @param status the status to search with
1360            * @param orderByComparator the comparator to order the set by
1361            * @return the previous, current, and next message boards thread
1362            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1363            * @throws SystemException if a system exception occurred
1364            */
1365            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_S_PrevAndNext(
1366                    long threadId, long groupId, long categoryId, int status,
1367                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1368                    throws com.liferay.portal.kernel.exception.SystemException,
1369                            com.liferay.portlet.messageboards.NoSuchThreadException {
1370                    return getPersistence()
1371                                       .findByG_NotC_S_PrevAndNext(threadId, groupId, categoryId,
1372                            status, orderByComparator);
1373            }
1374    
1375            /**
1376            * Finds all the message boards threads.
1377            *
1378            * @return the message boards threads
1379            * @throws SystemException if a system exception occurred
1380            */
1381            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll()
1382                    throws com.liferay.portal.kernel.exception.SystemException {
1383                    return getPersistence().findAll();
1384            }
1385    
1386            /**
1387            * Finds a range of all the message boards threads.
1388            *
1389            * <p>
1390            * 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.
1391            * </p>
1392            *
1393            * @param start the lower bound of the range of message boards threads to return
1394            * @param end the upper bound of the range of message boards threads to return (not inclusive)
1395            * @return the range of message boards threads
1396            * @throws SystemException if a system exception occurred
1397            */
1398            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll(
1399                    int start, int end)
1400                    throws com.liferay.portal.kernel.exception.SystemException {
1401                    return getPersistence().findAll(start, end);
1402            }
1403    
1404            /**
1405            * Finds an ordered range of all the message boards threads.
1406            *
1407            * <p>
1408            * 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.
1409            * </p>
1410            *
1411            * @param start the lower bound of the range of message boards threads to return
1412            * @param end the upper bound of the range of message boards threads to return (not inclusive)
1413            * @param orderByComparator the comparator to order the results by
1414            * @return the ordered range of message boards threads
1415            * @throws SystemException if a system exception occurred
1416            */
1417            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll(
1418                    int start, int end,
1419                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1420                    throws com.liferay.portal.kernel.exception.SystemException {
1421                    return getPersistence().findAll(start, end, orderByComparator);
1422            }
1423    
1424            /**
1425            * Removes all the message boards threads where groupId = &#63; from the database.
1426            *
1427            * @param groupId the group id to search with
1428            * @throws SystemException if a system exception occurred
1429            */
1430            public static void removeByGroupId(long groupId)
1431                    throws com.liferay.portal.kernel.exception.SystemException {
1432                    getPersistence().removeByGroupId(groupId);
1433            }
1434    
1435            /**
1436            * Removes all the message boards threads where groupId = &#63; and categoryId = &#63; from the database.
1437            *
1438            * @param groupId the group id to search with
1439            * @param categoryId the category id to search with
1440            * @throws SystemException if a system exception occurred
1441            */
1442            public static void removeByG_C(long groupId, long categoryId)
1443                    throws com.liferay.portal.kernel.exception.SystemException {
1444                    getPersistence().removeByG_C(groupId, categoryId);
1445            }
1446    
1447            /**
1448            * Removes all the message boards threads where groupId = &#63; and categoryId &ne; &#63; from the database.
1449            *
1450            * @param groupId the group id to search with
1451            * @param categoryId the category id to search with
1452            * @throws SystemException if a system exception occurred
1453            */
1454            public static void removeByG_NotC(long groupId, long categoryId)
1455                    throws com.liferay.portal.kernel.exception.SystemException {
1456                    getPersistence().removeByG_NotC(groupId, categoryId);
1457            }
1458    
1459            /**
1460            * Removes all the message boards threads where groupId = &#63; and status = &#63; from the database.
1461            *
1462            * @param groupId the group id to search with
1463            * @param status the status to search with
1464            * @throws SystemException if a system exception occurred
1465            */
1466            public static void removeByG_S(long groupId, int status)
1467                    throws com.liferay.portal.kernel.exception.SystemException {
1468                    getPersistence().removeByG_S(groupId, status);
1469            }
1470    
1471            /**
1472            * Removes all the message boards threads where categoryId = &#63; and priority = &#63; from the database.
1473            *
1474            * @param categoryId the category id to search with
1475            * @param priority the priority to search with
1476            * @throws SystemException if a system exception occurred
1477            */
1478            public static void removeByC_P(long categoryId, double priority)
1479                    throws com.liferay.portal.kernel.exception.SystemException {
1480                    getPersistence().removeByC_P(categoryId, priority);
1481            }
1482    
1483            /**
1484            * Removes all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63; from the database.
1485            *
1486            * @param groupId the group id to search with
1487            * @param categoryId the category id to search with
1488            * @param lastPostDate the last post date to search with
1489            * @throws SystemException if a system exception occurred
1490            */
1491            public static void removeByG_C_L(long groupId, long categoryId,
1492                    java.util.Date lastPostDate)
1493                    throws com.liferay.portal.kernel.exception.SystemException {
1494                    getPersistence().removeByG_C_L(groupId, categoryId, lastPostDate);
1495            }
1496    
1497            /**
1498            * Removes all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63; from the database.
1499            *
1500            * @param groupId the group id to search with
1501            * @param categoryId the category id to search with
1502            * @param status the status to search with
1503            * @throws SystemException if a system exception occurred
1504            */
1505            public static void removeByG_C_S(long groupId, long categoryId, int status)
1506                    throws com.liferay.portal.kernel.exception.SystemException {
1507                    getPersistence().removeByG_C_S(groupId, categoryId, status);
1508            }
1509    
1510            /**
1511            * Removes all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63; from the database.
1512            *
1513            * @param groupId the group id to search with
1514            * @param categoryId the category id to search with
1515            * @param status the status to search with
1516            * @throws SystemException if a system exception occurred
1517            */
1518            public static void removeByG_NotC_S(long groupId, long categoryId,
1519                    int status) throws com.liferay.portal.kernel.exception.SystemException {
1520                    getPersistence().removeByG_NotC_S(groupId, categoryId, status);
1521            }
1522    
1523            /**
1524            * Removes all the message boards threads from the database.
1525            *
1526            * @throws SystemException if a system exception occurred
1527            */
1528            public static void removeAll()
1529                    throws com.liferay.portal.kernel.exception.SystemException {
1530                    getPersistence().removeAll();
1531            }
1532    
1533            /**
1534            * Counts all the message boards threads where groupId = &#63;.
1535            *
1536            * @param groupId the group id to search with
1537            * @return the number of matching message boards threads
1538            * @throws SystemException if a system exception occurred
1539            */
1540            public static int countByGroupId(long groupId)
1541                    throws com.liferay.portal.kernel.exception.SystemException {
1542                    return getPersistence().countByGroupId(groupId);
1543            }
1544    
1545            /**
1546            * Counts all the message boards threads where groupId = &#63; and categoryId = &#63;.
1547            *
1548            * @param groupId the group id to search with
1549            * @param categoryId the category id to search with
1550            * @return the number of matching message boards threads
1551            * @throws SystemException if a system exception occurred
1552            */
1553            public static int countByG_C(long groupId, long categoryId)
1554                    throws com.liferay.portal.kernel.exception.SystemException {
1555                    return getPersistence().countByG_C(groupId, categoryId);
1556            }
1557    
1558            /**
1559            * Counts all the message boards threads where groupId = &#63; and categoryId = any &#63;.
1560            *
1561            * @param groupId the group id to search with
1562            * @param categoryIds the category ids to search with
1563            * @return the number of matching message boards threads
1564            * @throws SystemException if a system exception occurred
1565            */
1566            public static int countByG_C(long groupId, long[] categoryIds)
1567                    throws com.liferay.portal.kernel.exception.SystemException {
1568                    return getPersistence().countByG_C(groupId, categoryIds);
1569            }
1570    
1571            /**
1572            * Counts all the message boards threads where groupId = &#63; and categoryId &ne; &#63;.
1573            *
1574            * @param groupId the group id to search with
1575            * @param categoryId the category id to search with
1576            * @return the number of matching message boards threads
1577            * @throws SystemException if a system exception occurred
1578            */
1579            public static int countByG_NotC(long groupId, long categoryId)
1580                    throws com.liferay.portal.kernel.exception.SystemException {
1581                    return getPersistence().countByG_NotC(groupId, categoryId);
1582            }
1583    
1584            /**
1585            * Counts all the message boards threads where groupId = &#63; and status = &#63;.
1586            *
1587            * @param groupId the group id to search with
1588            * @param status the status to search with
1589            * @return the number of matching message boards threads
1590            * @throws SystemException if a system exception occurred
1591            */
1592            public static int countByG_S(long groupId, int status)
1593                    throws com.liferay.portal.kernel.exception.SystemException {
1594                    return getPersistence().countByG_S(groupId, status);
1595            }
1596    
1597            /**
1598            * Counts all the message boards threads where categoryId = &#63; and priority = &#63;.
1599            *
1600            * @param categoryId the category id to search with
1601            * @param priority the priority to search with
1602            * @return the number of matching message boards threads
1603            * @throws SystemException if a system exception occurred
1604            */
1605            public static int countByC_P(long categoryId, double priority)
1606                    throws com.liferay.portal.kernel.exception.SystemException {
1607                    return getPersistence().countByC_P(categoryId, priority);
1608            }
1609    
1610            /**
1611            * Counts all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1612            *
1613            * @param groupId the group id to search with
1614            * @param categoryId the category id to search with
1615            * @param lastPostDate the last post date to search with
1616            * @return the number of matching message boards threads
1617            * @throws SystemException if a system exception occurred
1618            */
1619            public static int countByG_C_L(long groupId, long categoryId,
1620                    java.util.Date lastPostDate)
1621                    throws com.liferay.portal.kernel.exception.SystemException {
1622                    return getPersistence().countByG_C_L(groupId, categoryId, lastPostDate);
1623            }
1624    
1625            /**
1626            * Counts all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
1627            *
1628            * @param groupId the group id to search with
1629            * @param categoryId the category id to search with
1630            * @param status the status to search with
1631            * @return the number of matching message boards threads
1632            * @throws SystemException if a system exception occurred
1633            */
1634            public static int countByG_C_S(long groupId, long categoryId, int status)
1635                    throws com.liferay.portal.kernel.exception.SystemException {
1636                    return getPersistence().countByG_C_S(groupId, categoryId, status);
1637            }
1638    
1639            /**
1640            * Counts all the message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
1641            *
1642            * @param groupId the group id to search with
1643            * @param categoryIds the category ids to search with
1644            * @param status the status to search with
1645            * @return the number of matching message boards threads
1646            * @throws SystemException if a system exception occurred
1647            */
1648            public static int countByG_C_S(long groupId, long[] categoryIds, int status)
1649                    throws com.liferay.portal.kernel.exception.SystemException {
1650                    return getPersistence().countByG_C_S(groupId, categoryIds, status);
1651            }
1652    
1653            /**
1654            * Counts all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
1655            *
1656            * @param groupId the group id to search with
1657            * @param categoryId the category id to search with
1658            * @param status the status to search with
1659            * @return the number of matching message boards threads
1660            * @throws SystemException if a system exception occurred
1661            */
1662            public static int countByG_NotC_S(long groupId, long categoryId, int status)
1663                    throws com.liferay.portal.kernel.exception.SystemException {
1664                    return getPersistence().countByG_NotC_S(groupId, categoryId, status);
1665            }
1666    
1667            /**
1668            * Counts all the message boards threads.
1669            *
1670            * @return the number of message boards threads
1671            * @throws SystemException if a system exception occurred
1672            */
1673            public static int countAll()
1674                    throws com.liferay.portal.kernel.exception.SystemException {
1675                    return getPersistence().countAll();
1676            }
1677    
1678            public static MBThreadPersistence getPersistence() {
1679                    if (_persistence == null) {
1680                            _persistence = (MBThreadPersistence)PortalBeanLocatorUtil.locate(MBThreadPersistence.class.getName());
1681                    }
1682    
1683                    return _persistence;
1684            }
1685    
1686            public void setPersistence(MBThreadPersistence persistence) {
1687                    _persistence = persistence;
1688            }
1689    
1690            private static MBThreadPersistence _persistence;
1691    }