001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.messageboards.service.persistence;
016    
017    import 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.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.messageboards.model.MBThread;
025    
026    import java.util.List;
027    
028    /**
029     * 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.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see MBThreadPersistence
037     * @see MBThreadPersistenceImpl
038     * @generated
039     */
040    public class MBThreadUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(MBThread mbThread) {
058                    getPersistence().clearCache(mbThread);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<MBThread> findWithDynamicQuery(DynamicQuery dynamicQuery)
073                    throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<MBThread> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<MBThread> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static MBThread update(MBThread mbThread) throws SystemException {
101                    return getPersistence().update(mbThread);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static MBThread update(MBThread mbThread,
108                    ServiceContext serviceContext) throws SystemException {
109                    return getPersistence().update(mbThread, serviceContext);
110            }
111    
112            /**
113            * Caches the message boards thread in the entity cache if it is enabled.
114            *
115            * @param mbThread the message boards thread
116            */
117            public static void cacheResult(
118                    com.liferay.portlet.messageboards.model.MBThread mbThread) {
119                    getPersistence().cacheResult(mbThread);
120            }
121    
122            /**
123            * Caches the message boards threads in the entity cache if it is enabled.
124            *
125            * @param mbThreads the message boards threads
126            */
127            public static void cacheResult(
128                    java.util.List<com.liferay.portlet.messageboards.model.MBThread> mbThreads) {
129                    getPersistence().cacheResult(mbThreads);
130            }
131    
132            /**
133            * Creates a new message boards thread with the primary key. Does not add the message boards thread to the database.
134            *
135            * @param threadId the primary key for the new message boards thread
136            * @return the new message boards thread
137            */
138            public static com.liferay.portlet.messageboards.model.MBThread create(
139                    long threadId) {
140                    return getPersistence().create(threadId);
141            }
142    
143            /**
144            * Removes the message boards thread with the primary key from the database. Also notifies the appropriate model listeners.
145            *
146            * @param threadId the primary key of the message boards thread
147            * @return the message boards thread that was removed
148            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
149            * @throws SystemException if a system exception occurred
150            */
151            public static com.liferay.portlet.messageboards.model.MBThread remove(
152                    long threadId)
153                    throws com.liferay.portal.kernel.exception.SystemException,
154                            com.liferay.portlet.messageboards.NoSuchThreadException {
155                    return getPersistence().remove(threadId);
156            }
157    
158            public static com.liferay.portlet.messageboards.model.MBThread updateImpl(
159                    com.liferay.portlet.messageboards.model.MBThread mbThread)
160                    throws com.liferay.portal.kernel.exception.SystemException {
161                    return getPersistence().updateImpl(mbThread);
162            }
163    
164            /**
165            * Returns the message boards thread with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found.
166            *
167            * @param threadId the primary key of the message boards thread
168            * @return the message boards thread
169            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
170            * @throws SystemException if a system exception occurred
171            */
172            public static com.liferay.portlet.messageboards.model.MBThread findByPrimaryKey(
173                    long threadId)
174                    throws com.liferay.portal.kernel.exception.SystemException,
175                            com.liferay.portlet.messageboards.NoSuchThreadException {
176                    return getPersistence().findByPrimaryKey(threadId);
177            }
178    
179            /**
180            * Returns the message boards thread with the primary key or returns <code>null</code> if it could not be found.
181            *
182            * @param threadId the primary key of the message boards thread
183            * @return the message boards thread, or <code>null</code> if a message boards thread with the primary key could not be found
184            * @throws SystemException if a system exception occurred
185            */
186            public static com.liferay.portlet.messageboards.model.MBThread fetchByPrimaryKey(
187                    long threadId)
188                    throws com.liferay.portal.kernel.exception.SystemException {
189                    return getPersistence().fetchByPrimaryKey(threadId);
190            }
191    
192            /**
193            * Returns all the message boards threads where groupId = &#63;.
194            *
195            * @param groupId the group ID
196            * @return the matching message boards threads
197            * @throws SystemException if a system exception occurred
198            */
199            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId(
200                    long groupId)
201                    throws com.liferay.portal.kernel.exception.SystemException {
202                    return getPersistence().findByGroupId(groupId);
203            }
204    
205            /**
206            * Returns a range of all the message boards threads where groupId = &#63;.
207            *
208            * <p>
209            * 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.
210            * </p>
211            *
212            * @param groupId the group ID
213            * @param start the lower bound of the range of message boards threads
214            * @param end the upper bound of the range of message boards threads (not inclusive)
215            * @return the range of matching message boards threads
216            * @throws SystemException if a system exception occurred
217            */
218            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId(
219                    long groupId, int start, int end)
220                    throws com.liferay.portal.kernel.exception.SystemException {
221                    return getPersistence().findByGroupId(groupId, start, end);
222            }
223    
224            /**
225            * Returns an ordered range of all the message boards threads where groupId = &#63;.
226            *
227            * <p>
228            * 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.
229            * </p>
230            *
231            * @param groupId the group ID
232            * @param start the lower bound of the range of message boards threads
233            * @param end the upper bound of the range of message boards threads (not inclusive)
234            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
235            * @return the ordered range of matching message boards threads
236            * @throws SystemException if a system exception occurred
237            */
238            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId(
239                    long groupId, int start, int end,
240                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
241                    throws com.liferay.portal.kernel.exception.SystemException {
242                    return getPersistence()
243                                       .findByGroupId(groupId, start, end, orderByComparator);
244            }
245    
246            /**
247            * Returns the first message boards thread in the ordered set where groupId = &#63;.
248            *
249            * @param groupId the group ID
250            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
251            * @return the first matching message boards thread
252            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
253            * @throws SystemException if a system exception occurred
254            */
255            public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_First(
256                    long groupId,
257                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
258                    throws com.liferay.portal.kernel.exception.SystemException,
259                            com.liferay.portlet.messageboards.NoSuchThreadException {
260                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
261            }
262    
263            /**
264            * Returns the first message boards thread in the ordered set where groupId = &#63;.
265            *
266            * @param groupId the group ID
267            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
268            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
269            * @throws SystemException if a system exception occurred
270            */
271            public static com.liferay.portlet.messageboards.model.MBThread fetchByGroupId_First(
272                    long groupId,
273                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
274                    throws com.liferay.portal.kernel.exception.SystemException {
275                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
276            }
277    
278            /**
279            * Returns the last message boards thread in the ordered set where groupId = &#63;.
280            *
281            * @param groupId the group ID
282            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
283            * @return the last matching message boards thread
284            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
285            * @throws SystemException if a system exception occurred
286            */
287            public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_Last(
288                    long groupId,
289                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
290                    throws com.liferay.portal.kernel.exception.SystemException,
291                            com.liferay.portlet.messageboards.NoSuchThreadException {
292                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
293            }
294    
295            /**
296            * Returns the last message boards thread in the ordered set where groupId = &#63;.
297            *
298            * @param groupId the group ID
299            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
300            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
301            * @throws SystemException if a system exception occurred
302            */
303            public static com.liferay.portlet.messageboards.model.MBThread fetchByGroupId_Last(
304                    long groupId,
305                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
306                    throws com.liferay.portal.kernel.exception.SystemException {
307                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
308            }
309    
310            /**
311            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63;.
312            *
313            * @param threadId the primary key of the current message boards thread
314            * @param groupId the group ID
315            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
316            * @return the previous, current, and next message boards thread
317            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
318            * @throws SystemException if a system exception occurred
319            */
320            public static com.liferay.portlet.messageboards.model.MBThread[] findByGroupId_PrevAndNext(
321                    long threadId, long groupId,
322                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
323                    throws com.liferay.portal.kernel.exception.SystemException,
324                            com.liferay.portlet.messageboards.NoSuchThreadException {
325                    return getPersistence()
326                                       .findByGroupId_PrevAndNext(threadId, groupId,
327                            orderByComparator);
328            }
329    
330            /**
331            * Returns all the message boards threads that the user has permission to view where groupId = &#63;.
332            *
333            * @param groupId the group ID
334            * @return the matching message boards threads that the user has permission to view
335            * @throws SystemException if a system exception occurred
336            */
337            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId(
338                    long groupId)
339                    throws com.liferay.portal.kernel.exception.SystemException {
340                    return getPersistence().filterFindByGroupId(groupId);
341            }
342    
343            /**
344            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63;.
345            *
346            * <p>
347            * 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.
348            * </p>
349            *
350            * @param groupId the group ID
351            * @param start the lower bound of the range of message boards threads
352            * @param end the upper bound of the range of message boards threads (not inclusive)
353            * @return the range of matching message boards threads that the user has permission to view
354            * @throws SystemException if a system exception occurred
355            */
356            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId(
357                    long groupId, int start, int end)
358                    throws com.liferay.portal.kernel.exception.SystemException {
359                    return getPersistence().filterFindByGroupId(groupId, start, end);
360            }
361    
362            /**
363            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63;.
364            *
365            * <p>
366            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
367            * </p>
368            *
369            * @param groupId the group ID
370            * @param start the lower bound of the range of message boards threads
371            * @param end the upper bound of the range of message boards threads (not inclusive)
372            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
373            * @return the ordered range of matching message boards threads that the user has permission to view
374            * @throws SystemException if a system exception occurred
375            */
376            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId(
377                    long groupId, int start, int end,
378                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
379                    throws com.liferay.portal.kernel.exception.SystemException {
380                    return getPersistence()
381                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
382            }
383    
384            /**
385            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63;.
386            *
387            * @param threadId the primary key of the current message boards thread
388            * @param groupId the group ID
389            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
390            * @return the previous, current, and next message boards thread
391            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
392            * @throws SystemException if a system exception occurred
393            */
394            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByGroupId_PrevAndNext(
395                    long threadId, long groupId,
396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
397                    throws com.liferay.portal.kernel.exception.SystemException,
398                            com.liferay.portlet.messageboards.NoSuchThreadException {
399                    return getPersistence()
400                                       .filterFindByGroupId_PrevAndNext(threadId, groupId,
401                            orderByComparator);
402            }
403    
404            /**
405            * Returns the message boards thread where rootMessageId = &#63; or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found.
406            *
407            * @param rootMessageId the root message ID
408            * @return the matching message boards thread
409            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
410            * @throws SystemException if a system exception occurred
411            */
412            public static com.liferay.portlet.messageboards.model.MBThread findByRootMessageId(
413                    long rootMessageId)
414                    throws com.liferay.portal.kernel.exception.SystemException,
415                            com.liferay.portlet.messageboards.NoSuchThreadException {
416                    return getPersistence().findByRootMessageId(rootMessageId);
417            }
418    
419            /**
420            * Returns the message boards thread where rootMessageId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
421            *
422            * @param rootMessageId the root message ID
423            * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
424            * @throws SystemException if a system exception occurred
425            */
426            public static com.liferay.portlet.messageboards.model.MBThread fetchByRootMessageId(
427                    long rootMessageId)
428                    throws com.liferay.portal.kernel.exception.SystemException {
429                    return getPersistence().fetchByRootMessageId(rootMessageId);
430            }
431    
432            /**
433            * Returns the message boards thread where rootMessageId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
434            *
435            * @param rootMessageId the root message ID
436            * @param retrieveFromCache whether to use the finder cache
437            * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
438            * @throws SystemException if a system exception occurred
439            */
440            public static com.liferay.portlet.messageboards.model.MBThread fetchByRootMessageId(
441                    long rootMessageId, boolean retrieveFromCache)
442                    throws com.liferay.portal.kernel.exception.SystemException {
443                    return getPersistence()
444                                       .fetchByRootMessageId(rootMessageId, retrieveFromCache);
445            }
446    
447            /**
448            * Returns all the message boards threads where groupId = &#63; and categoryId = &#63;.
449            *
450            * @param groupId the group ID
451            * @param categoryId the category ID
452            * @return the matching message boards threads
453            * @throws SystemException if a system exception occurred
454            */
455            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
456                    long groupId, long categoryId)
457                    throws com.liferay.portal.kernel.exception.SystemException {
458                    return getPersistence().findByG_C(groupId, categoryId);
459            }
460    
461            /**
462            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = &#63;.
463            *
464            * <p>
465            * 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.
466            * </p>
467            *
468            * @param groupId the group ID
469            * @param categoryId the category ID
470            * @param start the lower bound of the range of message boards threads
471            * @param end the upper bound of the range of message boards threads (not inclusive)
472            * @return the range of matching message boards threads
473            * @throws SystemException if a system exception occurred
474            */
475            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
476                    long groupId, long categoryId, int start, int end)
477                    throws com.liferay.portal.kernel.exception.SystemException {
478                    return getPersistence().findByG_C(groupId, categoryId, start, end);
479            }
480    
481            /**
482            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = &#63;.
483            *
484            * <p>
485            * 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.
486            * </p>
487            *
488            * @param groupId the group ID
489            * @param categoryId the category ID
490            * @param start the lower bound of the range of message boards threads
491            * @param end the upper bound of the range of message boards threads (not inclusive)
492            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
493            * @return the ordered range of matching message boards threads
494            * @throws SystemException if a system exception occurred
495            */
496            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
497                    long groupId, long categoryId, int start, int end,
498                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
499                    throws com.liferay.portal.kernel.exception.SystemException {
500                    return getPersistence()
501                                       .findByG_C(groupId, categoryId, start, end, orderByComparator);
502            }
503    
504            /**
505            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
506            *
507            * @param groupId the group ID
508            * @param categoryId the category ID
509            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
510            * @return the first matching message boards thread
511            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
512            * @throws SystemException if a system exception occurred
513            */
514            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_First(
515                    long groupId, long categoryId,
516                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
517                    throws com.liferay.portal.kernel.exception.SystemException,
518                            com.liferay.portlet.messageboards.NoSuchThreadException {
519                    return getPersistence()
520                                       .findByG_C_First(groupId, categoryId, orderByComparator);
521            }
522    
523            /**
524            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
525            *
526            * @param groupId the group ID
527            * @param categoryId the category ID
528            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
529            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
530            * @throws SystemException if a system exception occurred
531            */
532            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_First(
533                    long groupId, long categoryId,
534                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
535                    throws com.liferay.portal.kernel.exception.SystemException {
536                    return getPersistence()
537                                       .fetchByG_C_First(groupId, categoryId, orderByComparator);
538            }
539    
540            /**
541            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
542            *
543            * @param groupId the group ID
544            * @param categoryId the category ID
545            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
546            * @return the last matching message boards thread
547            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
548            * @throws SystemException if a system exception occurred
549            */
550            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_Last(
551                    long groupId, long categoryId,
552                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
553                    throws com.liferay.portal.kernel.exception.SystemException,
554                            com.liferay.portlet.messageboards.NoSuchThreadException {
555                    return getPersistence()
556                                       .findByG_C_Last(groupId, categoryId, orderByComparator);
557            }
558    
559            /**
560            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
561            *
562            * @param groupId the group ID
563            * @param categoryId the category ID
564            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
565            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
566            * @throws SystemException if a system exception occurred
567            */
568            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_Last(
569                    long groupId, long categoryId,
570                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
571                    throws com.liferay.portal.kernel.exception.SystemException {
572                    return getPersistence()
573                                       .fetchByG_C_Last(groupId, categoryId, orderByComparator);
574            }
575    
576            /**
577            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
578            *
579            * @param threadId the primary key of the current message boards thread
580            * @param groupId the group ID
581            * @param categoryId the category ID
582            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
583            * @return the previous, current, and next message boards thread
584            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
585            * @throws SystemException if a system exception occurred
586            */
587            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_PrevAndNext(
588                    long threadId, long groupId, long categoryId,
589                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
590                    throws com.liferay.portal.kernel.exception.SystemException,
591                            com.liferay.portlet.messageboards.NoSuchThreadException {
592                    return getPersistence()
593                                       .findByG_C_PrevAndNext(threadId, groupId, categoryId,
594                            orderByComparator);
595            }
596    
597            /**
598            * Returns all the message boards threads where groupId = &#63; and categoryId = any &#63;.
599            *
600            * <p>
601            * 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.
602            * </p>
603            *
604            * @param groupId the group ID
605            * @param categoryIds the category IDs
606            * @return the matching message boards threads
607            * @throws SystemException if a system exception occurred
608            */
609            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
610                    long groupId, long[] categoryIds)
611                    throws com.liferay.portal.kernel.exception.SystemException {
612                    return getPersistence().findByG_C(groupId, categoryIds);
613            }
614    
615            /**
616            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = any &#63;.
617            *
618            * <p>
619            * 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.
620            * </p>
621            *
622            * @param groupId the group ID
623            * @param categoryIds the category IDs
624            * @param start the lower bound of the range of message boards threads
625            * @param end the upper bound of the range of message boards threads (not inclusive)
626            * @return the range of matching message boards threads
627            * @throws SystemException if a system exception occurred
628            */
629            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
630                    long groupId, long[] categoryIds, int start, int end)
631                    throws com.liferay.portal.kernel.exception.SystemException {
632                    return getPersistence().findByG_C(groupId, categoryIds, start, end);
633            }
634    
635            /**
636            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = any &#63;.
637            *
638            * <p>
639            * 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.
640            * </p>
641            *
642            * @param groupId the group ID
643            * @param categoryIds the category IDs
644            * @param start the lower bound of the range of message boards threads
645            * @param end the upper bound of the range of message boards threads (not inclusive)
646            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
647            * @return the ordered range of matching message boards threads
648            * @throws SystemException if a system exception occurred
649            */
650            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
651                    long groupId, long[] categoryIds, int start, int end,
652                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
653                    throws com.liferay.portal.kernel.exception.SystemException {
654                    return getPersistence()
655                                       .findByG_C(groupId, categoryIds, start, end,
656                            orderByComparator);
657            }
658    
659            /**
660            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63;.
661            *
662            * @param groupId the group ID
663            * @param categoryId the category ID
664            * @return the matching message boards threads that the user has permission to view
665            * @throws SystemException if a system exception occurred
666            */
667            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
668                    long groupId, long categoryId)
669                    throws com.liferay.portal.kernel.exception.SystemException {
670                    return getPersistence().filterFindByG_C(groupId, categoryId);
671            }
672    
673            /**
674            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63;.
675            *
676            * <p>
677            * 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.
678            * </p>
679            *
680            * @param groupId the group ID
681            * @param categoryId the category ID
682            * @param start the lower bound of the range of message boards threads
683            * @param end the upper bound of the range of message boards threads (not inclusive)
684            * @return the range of matching message boards threads that the user has permission to view
685            * @throws SystemException if a system exception occurred
686            */
687            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
688                    long groupId, long categoryId, int start, int end)
689                    throws com.liferay.portal.kernel.exception.SystemException {
690                    return getPersistence().filterFindByG_C(groupId, categoryId, start, end);
691            }
692    
693            /**
694            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId = &#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
701            * @param categoryId the category ID
702            * @param start the lower bound of the range of message boards threads
703            * @param end the upper bound of the range of message boards threads (not inclusive)
704            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
705            * @return the ordered range of matching message boards threads that the user has permission to view
706            * @throws SystemException if a system exception occurred
707            */
708            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
709                    long groupId, long categoryId, int start, int end,
710                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
711                    throws com.liferay.portal.kernel.exception.SystemException {
712                    return getPersistence()
713                                       .filterFindByG_C(groupId, categoryId, start, end,
714                            orderByComparator);
715            }
716    
717            /**
718            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63;.
719            *
720            * @param threadId the primary key of the current message boards thread
721            * @param groupId the group ID
722            * @param categoryId the category ID
723            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
724            * @return the previous, current, and next message boards thread
725            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
726            * @throws SystemException if a system exception occurred
727            */
728            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_PrevAndNext(
729                    long threadId, long groupId, long categoryId,
730                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
731                    throws com.liferay.portal.kernel.exception.SystemException,
732                            com.liferay.portlet.messageboards.NoSuchThreadException {
733                    return getPersistence()
734                                       .filterFindByG_C_PrevAndNext(threadId, groupId, categoryId,
735                            orderByComparator);
736            }
737    
738            /**
739            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63;.
740            *
741            * @param groupId the group ID
742            * @param categoryIds the category IDs
743            * @return the matching message boards threads that the user has permission to view
744            * @throws SystemException if a system exception occurred
745            */
746            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
747                    long groupId, long[] categoryIds)
748                    throws com.liferay.portal.kernel.exception.SystemException {
749                    return getPersistence().filterFindByG_C(groupId, categoryIds);
750            }
751    
752            /**
753            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63;.
754            *
755            * <p>
756            * 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.
757            * </p>
758            *
759            * @param groupId the group ID
760            * @param categoryIds the category IDs
761            * @param start the lower bound of the range of message boards threads
762            * @param end the upper bound of the range of message boards threads (not inclusive)
763            * @return the range of matching message boards threads that the user has permission to view
764            * @throws SystemException if a system exception occurred
765            */
766            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
767                    long groupId, long[] categoryIds, int start, int end)
768                    throws com.liferay.portal.kernel.exception.SystemException {
769                    return getPersistence().filterFindByG_C(groupId, categoryIds, start, end);
770            }
771    
772            /**
773            * Returns an ordered range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63;.
774            *
775            * <p>
776            * 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.
777            * </p>
778            *
779            * @param groupId the group ID
780            * @param categoryIds the category IDs
781            * @param start the lower bound of the range of message boards threads
782            * @param end the upper bound of the range of message boards threads (not inclusive)
783            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
784            * @return the ordered range of matching message boards threads that the user has permission to view
785            * @throws SystemException if a system exception occurred
786            */
787            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
788                    long groupId, long[] categoryIds, int start, int end,
789                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
790                    throws com.liferay.portal.kernel.exception.SystemException {
791                    return getPersistence()
792                                       .filterFindByG_C(groupId, categoryIds, start, end,
793                            orderByComparator);
794            }
795    
796            /**
797            * Returns all the message boards threads where groupId = &#63; and categoryId &ne; &#63;.
798            *
799            * @param groupId the group ID
800            * @param categoryId the category ID
801            * @return the matching message boards threads
802            * @throws SystemException if a system exception occurred
803            */
804            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC(
805                    long groupId, long categoryId)
806                    throws com.liferay.portal.kernel.exception.SystemException {
807                    return getPersistence().findByG_NotC(groupId, categoryId);
808            }
809    
810            /**
811            * Returns a range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63;.
812            *
813            * <p>
814            * 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.
815            * </p>
816            *
817            * @param groupId the group ID
818            * @param categoryId the category ID
819            * @param start the lower bound of the range of message boards threads
820            * @param end the upper bound of the range of message boards threads (not inclusive)
821            * @return the range of matching message boards threads
822            * @throws SystemException if a system exception occurred
823            */
824            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC(
825                    long groupId, long categoryId, int start, int end)
826                    throws com.liferay.portal.kernel.exception.SystemException {
827                    return getPersistence().findByG_NotC(groupId, categoryId, start, end);
828            }
829    
830            /**
831            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63;.
832            *
833            * <p>
834            * 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.
835            * </p>
836            *
837            * @param groupId the group ID
838            * @param categoryId the category ID
839            * @param start the lower bound of the range of message boards threads
840            * @param end the upper bound of the range of message boards threads (not inclusive)
841            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
842            * @return the ordered range of matching message boards threads
843            * @throws SystemException if a system exception occurred
844            */
845            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC(
846                    long groupId, long categoryId, int start, int end,
847                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
848                    throws com.liferay.portal.kernel.exception.SystemException {
849                    return getPersistence()
850                                       .findByG_NotC(groupId, categoryId, start, end,
851                            orderByComparator);
852            }
853    
854            /**
855            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
856            *
857            * @param groupId the group ID
858            * @param categoryId the category ID
859            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
860            * @return the first matching message boards thread
861            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
862            * @throws SystemException if a system exception occurred
863            */
864            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_First(
865                    long groupId, long categoryId,
866                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
867                    throws com.liferay.portal.kernel.exception.SystemException,
868                            com.liferay.portlet.messageboards.NoSuchThreadException {
869                    return getPersistence()
870                                       .findByG_NotC_First(groupId, categoryId, orderByComparator);
871            }
872    
873            /**
874            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
875            *
876            * @param groupId the group ID
877            * @param categoryId the category ID
878            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
879            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
880            * @throws SystemException if a system exception occurred
881            */
882            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_First(
883                    long groupId, long categoryId,
884                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
885                    throws com.liferay.portal.kernel.exception.SystemException {
886                    return getPersistence()
887                                       .fetchByG_NotC_First(groupId, categoryId, orderByComparator);
888            }
889    
890            /**
891            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
892            *
893            * @param groupId the group ID
894            * @param categoryId the category ID
895            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
896            * @return the last matching message boards thread
897            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
898            * @throws SystemException if a system exception occurred
899            */
900            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_Last(
901                    long groupId, long categoryId,
902                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
903                    throws com.liferay.portal.kernel.exception.SystemException,
904                            com.liferay.portlet.messageboards.NoSuchThreadException {
905                    return getPersistence()
906                                       .findByG_NotC_Last(groupId, categoryId, orderByComparator);
907            }
908    
909            /**
910            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
911            *
912            * @param groupId the group ID
913            * @param categoryId the category ID
914            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
915            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
916            * @throws SystemException if a system exception occurred
917            */
918            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_Last(
919                    long groupId, long categoryId,
920                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
921                    throws com.liferay.portal.kernel.exception.SystemException {
922                    return getPersistence()
923                                       .fetchByG_NotC_Last(groupId, categoryId, orderByComparator);
924            }
925    
926            /**
927            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
928            *
929            * @param threadId the primary key of the current message boards thread
930            * @param groupId the group ID
931            * @param categoryId the category ID
932            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
933            * @return the previous, current, and next message boards thread
934            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
935            * @throws SystemException if a system exception occurred
936            */
937            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_PrevAndNext(
938                    long threadId, long groupId, long categoryId,
939                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
940                    throws com.liferay.portal.kernel.exception.SystemException,
941                            com.liferay.portlet.messageboards.NoSuchThreadException {
942                    return getPersistence()
943                                       .findByG_NotC_PrevAndNext(threadId, groupId, categoryId,
944                            orderByComparator);
945            }
946    
947            /**
948            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63;.
949            *
950            * @param groupId the group ID
951            * @param categoryId the category ID
952            * @return the matching message boards threads that the user has permission to view
953            * @throws SystemException if a system exception occurred
954            */
955            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC(
956                    long groupId, long categoryId)
957                    throws com.liferay.portal.kernel.exception.SystemException {
958                    return getPersistence().filterFindByG_NotC(groupId, categoryId);
959            }
960    
961            /**
962            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63;.
963            *
964            * <p>
965            * 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.
966            * </p>
967            *
968            * @param groupId the group ID
969            * @param categoryId the category ID
970            * @param start the lower bound of the range of message boards threads
971            * @param end the upper bound of the range of message boards threads (not inclusive)
972            * @return the range of matching message boards threads that the user has permission to view
973            * @throws SystemException if a system exception occurred
974            */
975            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC(
976                    long groupId, long categoryId, int start, int end)
977                    throws com.liferay.portal.kernel.exception.SystemException {
978                    return getPersistence()
979                                       .filterFindByG_NotC(groupId, categoryId, start, end);
980            }
981    
982            /**
983            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId &ne; &#63;.
984            *
985            * <p>
986            * 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.
987            * </p>
988            *
989            * @param groupId the group ID
990            * @param categoryId the category ID
991            * @param start the lower bound of the range of message boards threads
992            * @param end the upper bound of the range of message boards threads (not inclusive)
993            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
994            * @return the ordered range of matching message boards threads that the user has permission to view
995            * @throws SystemException if a system exception occurred
996            */
997            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC(
998                    long groupId, long categoryId, int start, int end,
999                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1000                    throws com.liferay.portal.kernel.exception.SystemException {
1001                    return getPersistence()
1002                                       .filterFindByG_NotC(groupId, categoryId, start, end,
1003                            orderByComparator);
1004            }
1005    
1006            /**
1007            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63;.
1008            *
1009            * @param threadId the primary key of the current message boards thread
1010            * @param groupId the group ID
1011            * @param categoryId the category ID
1012            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1013            * @return the previous, current, and next message boards thread
1014            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1015            * @throws SystemException if a system exception occurred
1016            */
1017            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_NotC_PrevAndNext(
1018                    long threadId, long groupId, long categoryId,
1019                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1020                    throws com.liferay.portal.kernel.exception.SystemException,
1021                            com.liferay.portlet.messageboards.NoSuchThreadException {
1022                    return getPersistence()
1023                                       .filterFindByG_NotC_PrevAndNext(threadId, groupId,
1024                            categoryId, orderByComparator);
1025            }
1026    
1027            /**
1028            * Returns all the message boards threads where groupId = &#63; and status = &#63;.
1029            *
1030            * @param groupId the group ID
1031            * @param status the status
1032            * @return the matching message boards threads
1033            * @throws SystemException if a system exception occurred
1034            */
1035            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S(
1036                    long groupId, int status)
1037                    throws com.liferay.portal.kernel.exception.SystemException {
1038                    return getPersistence().findByG_S(groupId, status);
1039            }
1040    
1041            /**
1042            * Returns a range of all the message boards threads where groupId = &#63; and status = &#63;.
1043            *
1044            * <p>
1045            * 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.
1046            * </p>
1047            *
1048            * @param groupId the group ID
1049            * @param status the status
1050            * @param start the lower bound of the range of message boards threads
1051            * @param end the upper bound of the range of message boards threads (not inclusive)
1052            * @return the range of matching message boards threads
1053            * @throws SystemException if a system exception occurred
1054            */
1055            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S(
1056                    long groupId, int status, int start, int end)
1057                    throws com.liferay.portal.kernel.exception.SystemException {
1058                    return getPersistence().findByG_S(groupId, status, start, end);
1059            }
1060    
1061            /**
1062            * Returns an ordered range of all the message boards threads where groupId = &#63; and status = &#63;.
1063            *
1064            * <p>
1065            * 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.
1066            * </p>
1067            *
1068            * @param groupId the group ID
1069            * @param status the status
1070            * @param start the lower bound of the range of message boards threads
1071            * @param end the upper bound of the range of message boards threads (not inclusive)
1072            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1073            * @return the ordered range of matching message boards threads
1074            * @throws SystemException if a system exception occurred
1075            */
1076            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S(
1077                    long groupId, int status, int start, int end,
1078                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1079                    throws com.liferay.portal.kernel.exception.SystemException {
1080                    return getPersistence()
1081                                       .findByG_S(groupId, status, start, end, orderByComparator);
1082            }
1083    
1084            /**
1085            * Returns the first message boards thread in the ordered set where groupId = &#63; and status = &#63;.
1086            *
1087            * @param groupId the group ID
1088            * @param status the status
1089            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1090            * @return the first matching message boards thread
1091            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1092            * @throws SystemException if a system exception occurred
1093            */
1094            public static com.liferay.portlet.messageboards.model.MBThread findByG_S_First(
1095                    long groupId, int status,
1096                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1097                    throws com.liferay.portal.kernel.exception.SystemException,
1098                            com.liferay.portlet.messageboards.NoSuchThreadException {
1099                    return getPersistence()
1100                                       .findByG_S_First(groupId, status, orderByComparator);
1101            }
1102    
1103            /**
1104            * Returns the first message boards thread in the ordered set where groupId = &#63; and status = &#63;.
1105            *
1106            * @param groupId the group ID
1107            * @param status the status
1108            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1109            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1110            * @throws SystemException if a system exception occurred
1111            */
1112            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_S_First(
1113                    long groupId, int status,
1114                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1115                    throws com.liferay.portal.kernel.exception.SystemException {
1116                    return getPersistence()
1117                                       .fetchByG_S_First(groupId, status, orderByComparator);
1118            }
1119    
1120            /**
1121            * Returns the last message boards thread in the ordered set where groupId = &#63; and status = &#63;.
1122            *
1123            * @param groupId the group ID
1124            * @param status the status
1125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1126            * @return the last matching message boards thread
1127            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1128            * @throws SystemException if a system exception occurred
1129            */
1130            public static com.liferay.portlet.messageboards.model.MBThread findByG_S_Last(
1131                    long groupId, int status,
1132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1133                    throws com.liferay.portal.kernel.exception.SystemException,
1134                            com.liferay.portlet.messageboards.NoSuchThreadException {
1135                    return getPersistence()
1136                                       .findByG_S_Last(groupId, status, orderByComparator);
1137            }
1138    
1139            /**
1140            * Returns the last message boards thread in the ordered set where groupId = &#63; and status = &#63;.
1141            *
1142            * @param groupId the group ID
1143            * @param status the status
1144            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1145            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1146            * @throws SystemException if a system exception occurred
1147            */
1148            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_S_Last(
1149                    long groupId, int status,
1150                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1151                    throws com.liferay.portal.kernel.exception.SystemException {
1152                    return getPersistence()
1153                                       .fetchByG_S_Last(groupId, status, orderByComparator);
1154            }
1155    
1156            /**
1157            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and status = &#63;.
1158            *
1159            * @param threadId the primary key of the current message boards thread
1160            * @param groupId the group ID
1161            * @param status the status
1162            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1163            * @return the previous, current, and next message boards thread
1164            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1165            * @throws SystemException if a system exception occurred
1166            */
1167            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_S_PrevAndNext(
1168                    long threadId, long groupId, int status,
1169                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1170                    throws com.liferay.portal.kernel.exception.SystemException,
1171                            com.liferay.portlet.messageboards.NoSuchThreadException {
1172                    return getPersistence()
1173                                       .findByG_S_PrevAndNext(threadId, groupId, status,
1174                            orderByComparator);
1175            }
1176    
1177            /**
1178            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and status = &#63;.
1179            *
1180            * @param groupId the group ID
1181            * @param status the status
1182            * @return the matching message boards threads that the user has permission to view
1183            * @throws SystemException if a system exception occurred
1184            */
1185            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S(
1186                    long groupId, int status)
1187                    throws com.liferay.portal.kernel.exception.SystemException {
1188                    return getPersistence().filterFindByG_S(groupId, status);
1189            }
1190    
1191            /**
1192            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and status = &#63;.
1193            *
1194            * <p>
1195            * 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.
1196            * </p>
1197            *
1198            * @param groupId the group ID
1199            * @param status the status
1200            * @param start the lower bound of the range of message boards threads
1201            * @param end the upper bound of the range of message boards threads (not inclusive)
1202            * @return the range of matching message boards threads that the user has permission to view
1203            * @throws SystemException if a system exception occurred
1204            */
1205            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S(
1206                    long groupId, int status, int start, int end)
1207                    throws com.liferay.portal.kernel.exception.SystemException {
1208                    return getPersistence().filterFindByG_S(groupId, status, start, end);
1209            }
1210    
1211            /**
1212            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and status = &#63;.
1213            *
1214            * <p>
1215            * 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.
1216            * </p>
1217            *
1218            * @param groupId the group ID
1219            * @param status the status
1220            * @param start the lower bound of the range of message boards threads
1221            * @param end the upper bound of the range of message boards threads (not inclusive)
1222            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1223            * @return the ordered range of matching message boards threads that the user has permission to view
1224            * @throws SystemException if a system exception occurred
1225            */
1226            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S(
1227                    long groupId, int status, int start, int end,
1228                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1229                    throws com.liferay.portal.kernel.exception.SystemException {
1230                    return getPersistence()
1231                                       .filterFindByG_S(groupId, status, start, end,
1232                            orderByComparator);
1233            }
1234    
1235            /**
1236            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and status = &#63;.
1237            *
1238            * @param threadId the primary key of the current message boards thread
1239            * @param groupId the group ID
1240            * @param status the status
1241            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1242            * @return the previous, current, and next message boards thread
1243            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1244            * @throws SystemException if a system exception occurred
1245            */
1246            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_S_PrevAndNext(
1247                    long threadId, long groupId, int status,
1248                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1249                    throws com.liferay.portal.kernel.exception.SystemException,
1250                            com.liferay.portlet.messageboards.NoSuchThreadException {
1251                    return getPersistence()
1252                                       .filterFindByG_S_PrevAndNext(threadId, groupId, status,
1253                            orderByComparator);
1254            }
1255    
1256            /**
1257            * Returns all the message boards threads where categoryId = &#63; and priority = &#63;.
1258            *
1259            * @param categoryId the category ID
1260            * @param priority the priority
1261            * @return the matching message boards threads
1262            * @throws SystemException if a system exception occurred
1263            */
1264            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P(
1265                    long categoryId, double priority)
1266                    throws com.liferay.portal.kernel.exception.SystemException {
1267                    return getPersistence().findByC_P(categoryId, priority);
1268            }
1269    
1270            /**
1271            * Returns a range of all the message boards threads where categoryId = &#63; and priority = &#63;.
1272            *
1273            * <p>
1274            * 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.
1275            * </p>
1276            *
1277            * @param categoryId the category ID
1278            * @param priority the priority
1279            * @param start the lower bound of the range of message boards threads
1280            * @param end the upper bound of the range of message boards threads (not inclusive)
1281            * @return the range of matching message boards threads
1282            * @throws SystemException if a system exception occurred
1283            */
1284            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P(
1285                    long categoryId, double priority, int start, int end)
1286                    throws com.liferay.portal.kernel.exception.SystemException {
1287                    return getPersistence().findByC_P(categoryId, priority, start, end);
1288            }
1289    
1290            /**
1291            * Returns an ordered range of all the message boards threads where categoryId = &#63; and priority = &#63;.
1292            *
1293            * <p>
1294            * 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.
1295            * </p>
1296            *
1297            * @param categoryId the category ID
1298            * @param priority the priority
1299            * @param start the lower bound of the range of message boards threads
1300            * @param end the upper bound of the range of message boards threads (not inclusive)
1301            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1302            * @return the ordered range of matching message boards threads
1303            * @throws SystemException if a system exception occurred
1304            */
1305            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P(
1306                    long categoryId, double priority, int start, int end,
1307                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1308                    throws com.liferay.portal.kernel.exception.SystemException {
1309                    return getPersistence()
1310                                       .findByC_P(categoryId, priority, start, end,
1311                            orderByComparator);
1312            }
1313    
1314            /**
1315            * Returns the first message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
1316            *
1317            * @param categoryId the category ID
1318            * @param priority the priority
1319            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1320            * @return the first matching message boards thread
1321            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1322            * @throws SystemException if a system exception occurred
1323            */
1324            public static com.liferay.portlet.messageboards.model.MBThread findByC_P_First(
1325                    long categoryId, double priority,
1326                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1327                    throws com.liferay.portal.kernel.exception.SystemException,
1328                            com.liferay.portlet.messageboards.NoSuchThreadException {
1329                    return getPersistence()
1330                                       .findByC_P_First(categoryId, priority, orderByComparator);
1331            }
1332    
1333            /**
1334            * Returns the first message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
1335            *
1336            * @param categoryId the category ID
1337            * @param priority the priority
1338            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1339            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1340            * @throws SystemException if a system exception occurred
1341            */
1342            public static com.liferay.portlet.messageboards.model.MBThread fetchByC_P_First(
1343                    long categoryId, double priority,
1344                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1345                    throws com.liferay.portal.kernel.exception.SystemException {
1346                    return getPersistence()
1347                                       .fetchByC_P_First(categoryId, priority, orderByComparator);
1348            }
1349    
1350            /**
1351            * Returns the last message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
1352            *
1353            * @param categoryId the category ID
1354            * @param priority the priority
1355            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1356            * @return the last matching message boards thread
1357            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1358            * @throws SystemException if a system exception occurred
1359            */
1360            public static com.liferay.portlet.messageboards.model.MBThread findByC_P_Last(
1361                    long categoryId, double priority,
1362                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1363                    throws com.liferay.portal.kernel.exception.SystemException,
1364                            com.liferay.portlet.messageboards.NoSuchThreadException {
1365                    return getPersistence()
1366                                       .findByC_P_Last(categoryId, priority, orderByComparator);
1367            }
1368    
1369            /**
1370            * Returns the last message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
1371            *
1372            * @param categoryId the category ID
1373            * @param priority the priority
1374            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1375            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1376            * @throws SystemException if a system exception occurred
1377            */
1378            public static com.liferay.portlet.messageboards.model.MBThread fetchByC_P_Last(
1379                    long categoryId, double priority,
1380                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1381                    throws com.liferay.portal.kernel.exception.SystemException {
1382                    return getPersistence()
1383                                       .fetchByC_P_Last(categoryId, priority, orderByComparator);
1384            }
1385    
1386            /**
1387            * Returns the message boards threads before and after the current message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
1388            *
1389            * @param threadId the primary key of the current message boards thread
1390            * @param categoryId the category ID
1391            * @param priority the priority
1392            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1393            * @return the previous, current, and next message boards thread
1394            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1395            * @throws SystemException if a system exception occurred
1396            */
1397            public static com.liferay.portlet.messageboards.model.MBThread[] findByC_P_PrevAndNext(
1398                    long threadId, long categoryId, double priority,
1399                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1400                    throws com.liferay.portal.kernel.exception.SystemException,
1401                            com.liferay.portlet.messageboards.NoSuchThreadException {
1402                    return getPersistence()
1403                                       .findByC_P_PrevAndNext(threadId, categoryId, priority,
1404                            orderByComparator);
1405            }
1406    
1407            /**
1408            * Returns all the message boards threads where lastPostDate = &#63; and priority = &#63;.
1409            *
1410            * @param lastPostDate the last post date
1411            * @param priority the priority
1412            * @return the matching message boards threads
1413            * @throws SystemException if a system exception occurred
1414            */
1415            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P(
1416                    java.util.Date lastPostDate, double priority)
1417                    throws com.liferay.portal.kernel.exception.SystemException {
1418                    return getPersistence().findByL_P(lastPostDate, priority);
1419            }
1420    
1421            /**
1422            * Returns a range of all the message boards threads where lastPostDate = &#63; and priority = &#63;.
1423            *
1424            * <p>
1425            * 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.
1426            * </p>
1427            *
1428            * @param lastPostDate the last post date
1429            * @param priority the priority
1430            * @param start the lower bound of the range of message boards threads
1431            * @param end the upper bound of the range of message boards threads (not inclusive)
1432            * @return the range of matching message boards threads
1433            * @throws SystemException if a system exception occurred
1434            */
1435            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P(
1436                    java.util.Date lastPostDate, double priority, int start, int end)
1437                    throws com.liferay.portal.kernel.exception.SystemException {
1438                    return getPersistence().findByL_P(lastPostDate, priority, start, end);
1439            }
1440    
1441            /**
1442            * Returns an ordered range of all the message boards threads where lastPostDate = &#63; and priority = &#63;.
1443            *
1444            * <p>
1445            * 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.
1446            * </p>
1447            *
1448            * @param lastPostDate the last post date
1449            * @param priority the priority
1450            * @param start the lower bound of the range of message boards threads
1451            * @param end the upper bound of the range of message boards threads (not inclusive)
1452            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1453            * @return the ordered range of matching message boards threads
1454            * @throws SystemException if a system exception occurred
1455            */
1456            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P(
1457                    java.util.Date lastPostDate, double priority, int start, int end,
1458                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1459                    throws com.liferay.portal.kernel.exception.SystemException {
1460                    return getPersistence()
1461                                       .findByL_P(lastPostDate, priority, start, end,
1462                            orderByComparator);
1463            }
1464    
1465            /**
1466            * Returns the first message boards thread in the ordered set where lastPostDate = &#63; and priority = &#63;.
1467            *
1468            * @param lastPostDate the last post date
1469            * @param priority the priority
1470            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1471            * @return the first matching message boards thread
1472            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1473            * @throws SystemException if a system exception occurred
1474            */
1475            public static com.liferay.portlet.messageboards.model.MBThread findByL_P_First(
1476                    java.util.Date lastPostDate, double priority,
1477                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1478                    throws com.liferay.portal.kernel.exception.SystemException,
1479                            com.liferay.portlet.messageboards.NoSuchThreadException {
1480                    return getPersistence()
1481                                       .findByL_P_First(lastPostDate, priority, orderByComparator);
1482            }
1483    
1484            /**
1485            * Returns the first message boards thread in the ordered set where lastPostDate = &#63; and priority = &#63;.
1486            *
1487            * @param lastPostDate the last post date
1488            * @param priority the priority
1489            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1490            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1491            * @throws SystemException if a system exception occurred
1492            */
1493            public static com.liferay.portlet.messageboards.model.MBThread fetchByL_P_First(
1494                    java.util.Date lastPostDate, double priority,
1495                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1496                    throws com.liferay.portal.kernel.exception.SystemException {
1497                    return getPersistence()
1498                                       .fetchByL_P_First(lastPostDate, priority, orderByComparator);
1499            }
1500    
1501            /**
1502            * Returns the last message boards thread in the ordered set where lastPostDate = &#63; and priority = &#63;.
1503            *
1504            * @param lastPostDate the last post date
1505            * @param priority the priority
1506            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1507            * @return the last matching message boards thread
1508            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1509            * @throws SystemException if a system exception occurred
1510            */
1511            public static com.liferay.portlet.messageboards.model.MBThread findByL_P_Last(
1512                    java.util.Date lastPostDate, double priority,
1513                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1514                    throws com.liferay.portal.kernel.exception.SystemException,
1515                            com.liferay.portlet.messageboards.NoSuchThreadException {
1516                    return getPersistence()
1517                                       .findByL_P_Last(lastPostDate, priority, orderByComparator);
1518            }
1519    
1520            /**
1521            * Returns the last message boards thread in the ordered set where lastPostDate = &#63; and priority = &#63;.
1522            *
1523            * @param lastPostDate the last post date
1524            * @param priority the priority
1525            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1526            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1527            * @throws SystemException if a system exception occurred
1528            */
1529            public static com.liferay.portlet.messageboards.model.MBThread fetchByL_P_Last(
1530                    java.util.Date lastPostDate, double priority,
1531                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1532                    throws com.liferay.portal.kernel.exception.SystemException {
1533                    return getPersistence()
1534                                       .fetchByL_P_Last(lastPostDate, priority, orderByComparator);
1535            }
1536    
1537            /**
1538            * Returns the message boards threads before and after the current message boards thread in the ordered set where lastPostDate = &#63; and priority = &#63;.
1539            *
1540            * @param threadId the primary key of the current message boards thread
1541            * @param lastPostDate the last post date
1542            * @param priority the priority
1543            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1544            * @return the previous, current, and next message boards thread
1545            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1546            * @throws SystemException if a system exception occurred
1547            */
1548            public static com.liferay.portlet.messageboards.model.MBThread[] findByL_P_PrevAndNext(
1549                    long threadId, java.util.Date lastPostDate, double priority,
1550                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1551                    throws com.liferay.portal.kernel.exception.SystemException,
1552                            com.liferay.portlet.messageboards.NoSuchThreadException {
1553                    return getPersistence()
1554                                       .findByL_P_PrevAndNext(threadId, lastPostDate, priority,
1555                            orderByComparator);
1556            }
1557    
1558            /**
1559            * Returns all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1560            *
1561            * @param groupId the group ID
1562            * @param categoryId the category ID
1563            * @param lastPostDate the last post date
1564            * @return the matching message boards threads
1565            * @throws SystemException if a system exception occurred
1566            */
1567            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L(
1568                    long groupId, long categoryId, java.util.Date lastPostDate)
1569                    throws com.liferay.portal.kernel.exception.SystemException {
1570                    return getPersistence().findByG_C_L(groupId, categoryId, lastPostDate);
1571            }
1572    
1573            /**
1574            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1575            *
1576            * <p>
1577            * 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.
1578            * </p>
1579            *
1580            * @param groupId the group ID
1581            * @param categoryId the category ID
1582            * @param lastPostDate the last post date
1583            * @param start the lower bound of the range of message boards threads
1584            * @param end the upper bound of the range of message boards threads (not inclusive)
1585            * @return the range of matching message boards threads
1586            * @throws SystemException if a system exception occurred
1587            */
1588            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L(
1589                    long groupId, long categoryId, java.util.Date lastPostDate, int start,
1590                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1591                    return getPersistence()
1592                                       .findByG_C_L(groupId, categoryId, lastPostDate, start, end);
1593            }
1594    
1595            /**
1596            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1597            *
1598            * <p>
1599            * 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.
1600            * </p>
1601            *
1602            * @param groupId the group ID
1603            * @param categoryId the category ID
1604            * @param lastPostDate the last post date
1605            * @param start the lower bound of the range of message boards threads
1606            * @param end the upper bound of the range of message boards threads (not inclusive)
1607            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1608            * @return the ordered range of matching message boards threads
1609            * @throws SystemException if a system exception occurred
1610            */
1611            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L(
1612                    long groupId, long categoryId, java.util.Date lastPostDate, int start,
1613                    int end,
1614                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1615                    throws com.liferay.portal.kernel.exception.SystemException {
1616                    return getPersistence()
1617                                       .findByG_C_L(groupId, categoryId, lastPostDate, start, end,
1618                            orderByComparator);
1619            }
1620    
1621            /**
1622            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1623            *
1624            * @param groupId the group ID
1625            * @param categoryId the category ID
1626            * @param lastPostDate the last post date
1627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1628            * @return the first matching message boards thread
1629            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1630            * @throws SystemException if a system exception occurred
1631            */
1632            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_First(
1633                    long groupId, long categoryId, java.util.Date lastPostDate,
1634                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1635                    throws com.liferay.portal.kernel.exception.SystemException,
1636                            com.liferay.portlet.messageboards.NoSuchThreadException {
1637                    return getPersistence()
1638                                       .findByG_C_L_First(groupId, categoryId, lastPostDate,
1639                            orderByComparator);
1640            }
1641    
1642            /**
1643            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1644            *
1645            * @param groupId the group ID
1646            * @param categoryId the category ID
1647            * @param lastPostDate the last post date
1648            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1649            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1650            * @throws SystemException if a system exception occurred
1651            */
1652            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_L_First(
1653                    long groupId, long categoryId, java.util.Date lastPostDate,
1654                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1655                    throws com.liferay.portal.kernel.exception.SystemException {
1656                    return getPersistence()
1657                                       .fetchByG_C_L_First(groupId, categoryId, lastPostDate,
1658                            orderByComparator);
1659            }
1660    
1661            /**
1662            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1663            *
1664            * @param groupId the group ID
1665            * @param categoryId the category ID
1666            * @param lastPostDate the last post date
1667            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1668            * @return the last matching message boards thread
1669            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1670            * @throws SystemException if a system exception occurred
1671            */
1672            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_Last(
1673                    long groupId, long categoryId, java.util.Date lastPostDate,
1674                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1675                    throws com.liferay.portal.kernel.exception.SystemException,
1676                            com.liferay.portlet.messageboards.NoSuchThreadException {
1677                    return getPersistence()
1678                                       .findByG_C_L_Last(groupId, categoryId, lastPostDate,
1679                            orderByComparator);
1680            }
1681    
1682            /**
1683            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1684            *
1685            * @param groupId the group ID
1686            * @param categoryId the category ID
1687            * @param lastPostDate the last post date
1688            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1689            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1690            * @throws SystemException if a system exception occurred
1691            */
1692            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_L_Last(
1693                    long groupId, long categoryId, java.util.Date lastPostDate,
1694                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1695                    throws com.liferay.portal.kernel.exception.SystemException {
1696                    return getPersistence()
1697                                       .fetchByG_C_L_Last(groupId, categoryId, lastPostDate,
1698                            orderByComparator);
1699            }
1700    
1701            /**
1702            * Returns 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;.
1703            *
1704            * @param threadId the primary key of the current message boards thread
1705            * @param groupId the group ID
1706            * @param categoryId the category ID
1707            * @param lastPostDate the last post date
1708            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1709            * @return the previous, current, and next message boards thread
1710            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1711            * @throws SystemException if a system exception occurred
1712            */
1713            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_L_PrevAndNext(
1714                    long threadId, long groupId, long categoryId,
1715                    java.util.Date lastPostDate,
1716                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1717                    throws com.liferay.portal.kernel.exception.SystemException,
1718                            com.liferay.portlet.messageboards.NoSuchThreadException {
1719                    return getPersistence()
1720                                       .findByG_C_L_PrevAndNext(threadId, groupId, categoryId,
1721                            lastPostDate, orderByComparator);
1722            }
1723    
1724            /**
1725            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1726            *
1727            * @param groupId the group ID
1728            * @param categoryId the category ID
1729            * @param lastPostDate the last post date
1730            * @return the matching message boards threads that the user has permission to view
1731            * @throws SystemException if a system exception occurred
1732            */
1733            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L(
1734                    long groupId, long categoryId, java.util.Date lastPostDate)
1735                    throws com.liferay.portal.kernel.exception.SystemException {
1736                    return getPersistence()
1737                                       .filterFindByG_C_L(groupId, categoryId, lastPostDate);
1738            }
1739    
1740            /**
1741            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1742            *
1743            * <p>
1744            * 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.
1745            * </p>
1746            *
1747            * @param groupId the group ID
1748            * @param categoryId the category ID
1749            * @param lastPostDate the last post date
1750            * @param start the lower bound of the range of message boards threads
1751            * @param end the upper bound of the range of message boards threads (not inclusive)
1752            * @return the range of matching message boards threads that the user has permission to view
1753            * @throws SystemException if a system exception occurred
1754            */
1755            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L(
1756                    long groupId, long categoryId, java.util.Date lastPostDate, int start,
1757                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1758                    return getPersistence()
1759                                       .filterFindByG_C_L(groupId, categoryId, lastPostDate, start,
1760                            end);
1761            }
1762    
1763            /**
1764            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1765            *
1766            * <p>
1767            * 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.
1768            * </p>
1769            *
1770            * @param groupId the group ID
1771            * @param categoryId the category ID
1772            * @param lastPostDate the last post date
1773            * @param start the lower bound of the range of message boards threads
1774            * @param end the upper bound of the range of message boards threads (not inclusive)
1775            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1776            * @return the ordered range of matching message boards threads that the user has permission to view
1777            * @throws SystemException if a system exception occurred
1778            */
1779            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L(
1780                    long groupId, long categoryId, java.util.Date lastPostDate, int start,
1781                    int end,
1782                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1783                    throws com.liferay.portal.kernel.exception.SystemException {
1784                    return getPersistence()
1785                                       .filterFindByG_C_L(groupId, categoryId, lastPostDate, start,
1786                            end, orderByComparator);
1787            }
1788    
1789            /**
1790            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
1791            *
1792            * @param threadId the primary key of the current message boards thread
1793            * @param groupId the group ID
1794            * @param categoryId the category ID
1795            * @param lastPostDate the last post date
1796            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1797            * @return the previous, current, and next message boards thread
1798            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1799            * @throws SystemException if a system exception occurred
1800            */
1801            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_L_PrevAndNext(
1802                    long threadId, long groupId, long categoryId,
1803                    java.util.Date lastPostDate,
1804                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1805                    throws com.liferay.portal.kernel.exception.SystemException,
1806                            com.liferay.portlet.messageboards.NoSuchThreadException {
1807                    return getPersistence()
1808                                       .filterFindByG_C_L_PrevAndNext(threadId, groupId,
1809                            categoryId, lastPostDate, orderByComparator);
1810            }
1811    
1812            /**
1813            * Returns all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
1814            *
1815            * @param groupId the group ID
1816            * @param categoryId the category ID
1817            * @param status the status
1818            * @return the matching message boards threads
1819            * @throws SystemException if a system exception occurred
1820            */
1821            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
1822                    long groupId, long categoryId, int status)
1823                    throws com.liferay.portal.kernel.exception.SystemException {
1824                    return getPersistence().findByG_C_S(groupId, categoryId, status);
1825            }
1826    
1827            /**
1828            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
1829            *
1830            * <p>
1831            * 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.
1832            * </p>
1833            *
1834            * @param groupId the group ID
1835            * @param categoryId the category ID
1836            * @param status the status
1837            * @param start the lower bound of the range of message boards threads
1838            * @param end the upper bound of the range of message boards threads (not inclusive)
1839            * @return the range of matching message boards threads
1840            * @throws SystemException if a system exception occurred
1841            */
1842            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
1843                    long groupId, long categoryId, int status, int start, int end)
1844                    throws com.liferay.portal.kernel.exception.SystemException {
1845                    return getPersistence()
1846                                       .findByG_C_S(groupId, categoryId, status, start, end);
1847            }
1848    
1849            /**
1850            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
1851            *
1852            * <p>
1853            * 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.
1854            * </p>
1855            *
1856            * @param groupId the group ID
1857            * @param categoryId the category ID
1858            * @param status the status
1859            * @param start the lower bound of the range of message boards threads
1860            * @param end the upper bound of the range of message boards threads (not inclusive)
1861            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1862            * @return the ordered range of matching message boards threads
1863            * @throws SystemException if a system exception occurred
1864            */
1865            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
1866                    long groupId, long categoryId, int status, int start, int end,
1867                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1868                    throws com.liferay.portal.kernel.exception.SystemException {
1869                    return getPersistence()
1870                                       .findByG_C_S(groupId, categoryId, status, start, end,
1871                            orderByComparator);
1872            }
1873    
1874            /**
1875            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
1876            *
1877            * @param groupId the group ID
1878            * @param categoryId the category ID
1879            * @param status the status
1880            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1881            * @return the first matching message boards thread
1882            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1883            * @throws SystemException if a system exception occurred
1884            */
1885            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_First(
1886                    long groupId, long categoryId, int status,
1887                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1888                    throws com.liferay.portal.kernel.exception.SystemException,
1889                            com.liferay.portlet.messageboards.NoSuchThreadException {
1890                    return getPersistence()
1891                                       .findByG_C_S_First(groupId, categoryId, status,
1892                            orderByComparator);
1893            }
1894    
1895            /**
1896            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
1897            *
1898            * @param groupId the group ID
1899            * @param categoryId the category ID
1900            * @param status the status
1901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1902            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1903            * @throws SystemException if a system exception occurred
1904            */
1905            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_S_First(
1906                    long groupId, long categoryId, int status,
1907                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1908                    throws com.liferay.portal.kernel.exception.SystemException {
1909                    return getPersistence()
1910                                       .fetchByG_C_S_First(groupId, categoryId, status,
1911                            orderByComparator);
1912            }
1913    
1914            /**
1915            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
1916            *
1917            * @param groupId the group ID
1918            * @param categoryId the category ID
1919            * @param status the status
1920            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1921            * @return the last matching message boards thread
1922            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1923            * @throws SystemException if a system exception occurred
1924            */
1925            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_Last(
1926                    long groupId, long categoryId, int status,
1927                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1928                    throws com.liferay.portal.kernel.exception.SystemException,
1929                            com.liferay.portlet.messageboards.NoSuchThreadException {
1930                    return getPersistence()
1931                                       .findByG_C_S_Last(groupId, categoryId, status,
1932                            orderByComparator);
1933            }
1934    
1935            /**
1936            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
1937            *
1938            * @param groupId the group ID
1939            * @param categoryId the category ID
1940            * @param status the status
1941            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1942            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1943            * @throws SystemException if a system exception occurred
1944            */
1945            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_S_Last(
1946                    long groupId, long categoryId, int status,
1947                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1948                    throws com.liferay.portal.kernel.exception.SystemException {
1949                    return getPersistence()
1950                                       .fetchByG_C_S_Last(groupId, categoryId, status,
1951                            orderByComparator);
1952            }
1953    
1954            /**
1955            * Returns 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;.
1956            *
1957            * @param threadId the primary key of the current message boards thread
1958            * @param groupId the group ID
1959            * @param categoryId the category ID
1960            * @param status the status
1961            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1962            * @return the previous, current, and next message boards thread
1963            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1964            * @throws SystemException if a system exception occurred
1965            */
1966            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_S_PrevAndNext(
1967                    long threadId, long groupId, long categoryId, int status,
1968                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1969                    throws com.liferay.portal.kernel.exception.SystemException,
1970                            com.liferay.portlet.messageboards.NoSuchThreadException {
1971                    return getPersistence()
1972                                       .findByG_C_S_PrevAndNext(threadId, groupId, categoryId,
1973                            status, orderByComparator);
1974            }
1975    
1976            /**
1977            * Returns all the message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
1978            *
1979            * <p>
1980            * 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.
1981            * </p>
1982            *
1983            * @param groupId the group ID
1984            * @param categoryIds the category IDs
1985            * @param status the status
1986            * @return the matching message boards threads
1987            * @throws SystemException if a system exception occurred
1988            */
1989            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
1990                    long groupId, long[] categoryIds, int status)
1991                    throws com.liferay.portal.kernel.exception.SystemException {
1992                    return getPersistence().findByG_C_S(groupId, categoryIds, status);
1993            }
1994    
1995            /**
1996            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
1997            *
1998            * <p>
1999            * 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.
2000            * </p>
2001            *
2002            * @param groupId the group ID
2003            * @param categoryIds the category IDs
2004            * @param status the status
2005            * @param start the lower bound of the range of message boards threads
2006            * @param end the upper bound of the range of message boards threads (not inclusive)
2007            * @return the range of matching message boards threads
2008            * @throws SystemException if a system exception occurred
2009            */
2010            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
2011                    long groupId, long[] categoryIds, int status, int start, int end)
2012                    throws com.liferay.portal.kernel.exception.SystemException {
2013                    return getPersistence()
2014                                       .findByG_C_S(groupId, categoryIds, status, start, end);
2015            }
2016    
2017            /**
2018            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2019            *
2020            * <p>
2021            * 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.
2022            * </p>
2023            *
2024            * @param groupId the group ID
2025            * @param categoryIds the category IDs
2026            * @param status the status
2027            * @param start the lower bound of the range of message boards threads
2028            * @param end the upper bound of the range of message boards threads (not inclusive)
2029            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2030            * @return the ordered range of matching message boards threads
2031            * @throws SystemException if a system exception occurred
2032            */
2033            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
2034                    long groupId, long[] categoryIds, int status, int start, int end,
2035                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2036                    throws com.liferay.portal.kernel.exception.SystemException {
2037                    return getPersistence()
2038                                       .findByG_C_S(groupId, categoryIds, status, start, end,
2039                            orderByComparator);
2040            }
2041    
2042            /**
2043            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
2044            *
2045            * @param groupId the group ID
2046            * @param categoryId the category ID
2047            * @param status the status
2048            * @return the matching message boards threads that the user has permission to view
2049            * @throws SystemException if a system exception occurred
2050            */
2051            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2052                    long groupId, long categoryId, int status)
2053                    throws com.liferay.portal.kernel.exception.SystemException {
2054                    return getPersistence().filterFindByG_C_S(groupId, categoryId, status);
2055            }
2056    
2057            /**
2058            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
2059            *
2060            * <p>
2061            * 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.
2062            * </p>
2063            *
2064            * @param groupId the group ID
2065            * @param categoryId the category ID
2066            * @param status the status
2067            * @param start the lower bound of the range of message boards threads
2068            * @param end the upper bound of the range of message boards threads (not inclusive)
2069            * @return the range of matching message boards threads that the user has permission to view
2070            * @throws SystemException if a system exception occurred
2071            */
2072            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2073                    long groupId, long categoryId, int status, int start, int end)
2074                    throws com.liferay.portal.kernel.exception.SystemException {
2075                    return getPersistence()
2076                                       .filterFindByG_C_S(groupId, categoryId, status, start, end);
2077            }
2078    
2079            /**
2080            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
2081            *
2082            * <p>
2083            * 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.
2084            * </p>
2085            *
2086            * @param groupId the group ID
2087            * @param categoryId the category ID
2088            * @param status the status
2089            * @param start the lower bound of the range of message boards threads
2090            * @param end the upper bound of the range of message boards threads (not inclusive)
2091            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2092            * @return the ordered range of matching message boards threads that the user has permission to view
2093            * @throws SystemException if a system exception occurred
2094            */
2095            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2096                    long groupId, long categoryId, int status, int start, int end,
2097                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2098                    throws com.liferay.portal.kernel.exception.SystemException {
2099                    return getPersistence()
2100                                       .filterFindByG_C_S(groupId, categoryId, status, start, end,
2101                            orderByComparator);
2102            }
2103    
2104            /**
2105            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
2106            *
2107            * @param threadId the primary key of the current message boards thread
2108            * @param groupId the group ID
2109            * @param categoryId the category ID
2110            * @param status the status
2111            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2112            * @return the previous, current, and next message boards thread
2113            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
2114            * @throws SystemException if a system exception occurred
2115            */
2116            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_S_PrevAndNext(
2117                    long threadId, long groupId, long categoryId, int status,
2118                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2119                    throws com.liferay.portal.kernel.exception.SystemException,
2120                            com.liferay.portlet.messageboards.NoSuchThreadException {
2121                    return getPersistence()
2122                                       .filterFindByG_C_S_PrevAndNext(threadId, groupId,
2123                            categoryId, status, orderByComparator);
2124            }
2125    
2126            /**
2127            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2128            *
2129            * @param groupId the group ID
2130            * @param categoryIds the category IDs
2131            * @param status the status
2132            * @return the matching message boards threads that the user has permission to view
2133            * @throws SystemException if a system exception occurred
2134            */
2135            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2136                    long groupId, long[] categoryIds, int status)
2137                    throws com.liferay.portal.kernel.exception.SystemException {
2138                    return getPersistence().filterFindByG_C_S(groupId, categoryIds, status);
2139            }
2140    
2141            /**
2142            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2143            *
2144            * <p>
2145            * 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.
2146            * </p>
2147            *
2148            * @param groupId the group ID
2149            * @param categoryIds the category IDs
2150            * @param status the status
2151            * @param start the lower bound of the range of message boards threads
2152            * @param end the upper bound of the range of message boards threads (not inclusive)
2153            * @return the range of matching message boards threads that the user has permission to view
2154            * @throws SystemException if a system exception occurred
2155            */
2156            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2157                    long groupId, long[] categoryIds, int status, int start, int end)
2158                    throws com.liferay.portal.kernel.exception.SystemException {
2159                    return getPersistence()
2160                                       .filterFindByG_C_S(groupId, categoryIds, status, start, end);
2161            }
2162    
2163            /**
2164            * Returns an ordered range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2165            *
2166            * <p>
2167            * 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.
2168            * </p>
2169            *
2170            * @param groupId the group ID
2171            * @param categoryIds the category IDs
2172            * @param status the status
2173            * @param start the lower bound of the range of message boards threads
2174            * @param end the upper bound of the range of message boards threads (not inclusive)
2175            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2176            * @return the ordered range of matching message boards threads that the user has permission to view
2177            * @throws SystemException if a system exception occurred
2178            */
2179            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2180                    long groupId, long[] categoryIds, int status, int start, int end,
2181                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2182                    throws com.liferay.portal.kernel.exception.SystemException {
2183                    return getPersistence()
2184                                       .filterFindByG_C_S(groupId, categoryIds, status, start, end,
2185                            orderByComparator);
2186            }
2187    
2188            /**
2189            * Returns all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2190            *
2191            * @param groupId the group ID
2192            * @param categoryId the category ID
2193            * @param status the status
2194            * @return the matching message boards threads
2195            * @throws SystemException if a system exception occurred
2196            */
2197            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S(
2198                    long groupId, long categoryId, int status)
2199                    throws com.liferay.portal.kernel.exception.SystemException {
2200                    return getPersistence().findByG_NotC_S(groupId, categoryId, status);
2201            }
2202    
2203            /**
2204            * Returns a range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2205            *
2206            * <p>
2207            * 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.
2208            * </p>
2209            *
2210            * @param groupId the group ID
2211            * @param categoryId the category ID
2212            * @param status the status
2213            * @param start the lower bound of the range of message boards threads
2214            * @param end the upper bound of the range of message boards threads (not inclusive)
2215            * @return the range of matching message boards threads
2216            * @throws SystemException if a system exception occurred
2217            */
2218            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S(
2219                    long groupId, long categoryId, int status, int start, int end)
2220                    throws com.liferay.portal.kernel.exception.SystemException {
2221                    return getPersistence()
2222                                       .findByG_NotC_S(groupId, categoryId, status, start, end);
2223            }
2224    
2225            /**
2226            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2227            *
2228            * <p>
2229            * 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.
2230            * </p>
2231            *
2232            * @param groupId the group ID
2233            * @param categoryId the category ID
2234            * @param status the status
2235            * @param start the lower bound of the range of message boards threads
2236            * @param end the upper bound of the range of message boards threads (not inclusive)
2237            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2238            * @return the ordered range of matching message boards threads
2239            * @throws SystemException if a system exception occurred
2240            */
2241            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S(
2242                    long groupId, long categoryId, int status, int start, int end,
2243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2244                    throws com.liferay.portal.kernel.exception.SystemException {
2245                    return getPersistence()
2246                                       .findByG_NotC_S(groupId, categoryId, status, start, end,
2247                            orderByComparator);
2248            }
2249    
2250            /**
2251            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2252            *
2253            * @param groupId the group ID
2254            * @param categoryId the category ID
2255            * @param status the status
2256            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2257            * @return the first matching message boards thread
2258            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
2259            * @throws SystemException if a system exception occurred
2260            */
2261            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_First(
2262                    long groupId, long categoryId, int status,
2263                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2264                    throws com.liferay.portal.kernel.exception.SystemException,
2265                            com.liferay.portlet.messageboards.NoSuchThreadException {
2266                    return getPersistence()
2267                                       .findByG_NotC_S_First(groupId, categoryId, status,
2268                            orderByComparator);
2269            }
2270    
2271            /**
2272            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2273            *
2274            * @param groupId the group ID
2275            * @param categoryId the category ID
2276            * @param status the status
2277            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2278            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
2279            * @throws SystemException if a system exception occurred
2280            */
2281            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_S_First(
2282                    long groupId, long categoryId, int status,
2283                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2284                    throws com.liferay.portal.kernel.exception.SystemException {
2285                    return getPersistence()
2286                                       .fetchByG_NotC_S_First(groupId, categoryId, status,
2287                            orderByComparator);
2288            }
2289    
2290            /**
2291            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2292            *
2293            * @param groupId the group ID
2294            * @param categoryId the category ID
2295            * @param status the status
2296            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2297            * @return the last matching message boards thread
2298            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
2299            * @throws SystemException if a system exception occurred
2300            */
2301            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_Last(
2302                    long groupId, long categoryId, int status,
2303                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2304                    throws com.liferay.portal.kernel.exception.SystemException,
2305                            com.liferay.portlet.messageboards.NoSuchThreadException {
2306                    return getPersistence()
2307                                       .findByG_NotC_S_Last(groupId, categoryId, status,
2308                            orderByComparator);
2309            }
2310    
2311            /**
2312            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2313            *
2314            * @param groupId the group ID
2315            * @param categoryId the category ID
2316            * @param status the status
2317            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2318            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
2319            * @throws SystemException if a system exception occurred
2320            */
2321            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_S_Last(
2322                    long groupId, long categoryId, int status,
2323                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2324                    throws com.liferay.portal.kernel.exception.SystemException {
2325                    return getPersistence()
2326                                       .fetchByG_NotC_S_Last(groupId, categoryId, status,
2327                            orderByComparator);
2328            }
2329    
2330            /**
2331            * Returns 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;.
2332            *
2333            * @param threadId the primary key of the current message boards thread
2334            * @param groupId the group ID
2335            * @param categoryId the category ID
2336            * @param status the status
2337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2338            * @return the previous, current, and next message boards thread
2339            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
2340            * @throws SystemException if a system exception occurred
2341            */
2342            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_S_PrevAndNext(
2343                    long threadId, long groupId, long categoryId, int status,
2344                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2345                    throws com.liferay.portal.kernel.exception.SystemException,
2346                            com.liferay.portlet.messageboards.NoSuchThreadException {
2347                    return getPersistence()
2348                                       .findByG_NotC_S_PrevAndNext(threadId, groupId, categoryId,
2349                            status, orderByComparator);
2350            }
2351    
2352            /**
2353            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2354            *
2355            * @param groupId the group ID
2356            * @param categoryId the category ID
2357            * @param status the status
2358            * @return the matching message boards threads that the user has permission to view
2359            * @throws SystemException if a system exception occurred
2360            */
2361            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S(
2362                    long groupId, long categoryId, int status)
2363                    throws com.liferay.portal.kernel.exception.SystemException {
2364                    return getPersistence().filterFindByG_NotC_S(groupId, categoryId, status);
2365            }
2366    
2367            /**
2368            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2369            *
2370            * <p>
2371            * 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.
2372            * </p>
2373            *
2374            * @param groupId the group ID
2375            * @param categoryId the category ID
2376            * @param status the status
2377            * @param start the lower bound of the range of message boards threads
2378            * @param end the upper bound of the range of message boards threads (not inclusive)
2379            * @return the range of matching message boards threads that the user has permission to view
2380            * @throws SystemException if a system exception occurred
2381            */
2382            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S(
2383                    long groupId, long categoryId, int status, int start, int end)
2384                    throws com.liferay.portal.kernel.exception.SystemException {
2385                    return getPersistence()
2386                                       .filterFindByG_NotC_S(groupId, categoryId, status, start, end);
2387            }
2388    
2389            /**
2390            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2391            *
2392            * <p>
2393            * 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.
2394            * </p>
2395            *
2396            * @param groupId the group ID
2397            * @param categoryId the category ID
2398            * @param status the status
2399            * @param start the lower bound of the range of message boards threads
2400            * @param end the upper bound of the range of message boards threads (not inclusive)
2401            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2402            * @return the ordered range of matching message boards threads that the user has permission to view
2403            * @throws SystemException if a system exception occurred
2404            */
2405            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S(
2406                    long groupId, long categoryId, int status, int start, int end,
2407                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2408                    throws com.liferay.portal.kernel.exception.SystemException {
2409                    return getPersistence()
2410                                       .filterFindByG_NotC_S(groupId, categoryId, status, start,
2411                            end, orderByComparator);
2412            }
2413    
2414            /**
2415            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2416            *
2417            * @param threadId the primary key of the current message boards thread
2418            * @param groupId the group ID
2419            * @param categoryId the category ID
2420            * @param status the status
2421            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2422            * @return the previous, current, and next message boards thread
2423            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
2424            * @throws SystemException if a system exception occurred
2425            */
2426            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_NotC_S_PrevAndNext(
2427                    long threadId, long groupId, long categoryId, int status,
2428                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2429                    throws com.liferay.portal.kernel.exception.SystemException,
2430                            com.liferay.portlet.messageboards.NoSuchThreadException {
2431                    return getPersistence()
2432                                       .filterFindByG_NotC_S_PrevAndNext(threadId, groupId,
2433                            categoryId, status, orderByComparator);
2434            }
2435    
2436            /**
2437            * Returns all the message boards threads.
2438            *
2439            * @return the message boards threads
2440            * @throws SystemException if a system exception occurred
2441            */
2442            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll()
2443                    throws com.liferay.portal.kernel.exception.SystemException {
2444                    return getPersistence().findAll();
2445            }
2446    
2447            /**
2448            * Returns a range of all the message boards threads.
2449            *
2450            * <p>
2451            * 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.
2452            * </p>
2453            *
2454            * @param start the lower bound of the range of message boards threads
2455            * @param end the upper bound of the range of message boards threads (not inclusive)
2456            * @return the range of message boards threads
2457            * @throws SystemException if a system exception occurred
2458            */
2459            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll(
2460                    int start, int end)
2461                    throws com.liferay.portal.kernel.exception.SystemException {
2462                    return getPersistence().findAll(start, end);
2463            }
2464    
2465            /**
2466            * Returns an ordered range of all the message boards threads.
2467            *
2468            * <p>
2469            * 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.
2470            * </p>
2471            *
2472            * @param start the lower bound of the range of message boards threads
2473            * @param end the upper bound of the range of message boards threads (not inclusive)
2474            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2475            * @return the ordered range of message boards threads
2476            * @throws SystemException if a system exception occurred
2477            */
2478            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll(
2479                    int start, int end,
2480                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2481                    throws com.liferay.portal.kernel.exception.SystemException {
2482                    return getPersistence().findAll(start, end, orderByComparator);
2483            }
2484    
2485            /**
2486            * Removes all the message boards threads where groupId = &#63; from the database.
2487            *
2488            * @param groupId the group ID
2489            * @throws SystemException if a system exception occurred
2490            */
2491            public static void removeByGroupId(long groupId)
2492                    throws com.liferay.portal.kernel.exception.SystemException {
2493                    getPersistence().removeByGroupId(groupId);
2494            }
2495    
2496            /**
2497            * Removes the message boards thread where rootMessageId = &#63; from the database.
2498            *
2499            * @param rootMessageId the root message ID
2500            * @return the message boards thread that was removed
2501            * @throws SystemException if a system exception occurred
2502            */
2503            public static com.liferay.portlet.messageboards.model.MBThread removeByRootMessageId(
2504                    long rootMessageId)
2505                    throws com.liferay.portal.kernel.exception.SystemException,
2506                            com.liferay.portlet.messageboards.NoSuchThreadException {
2507                    return getPersistence().removeByRootMessageId(rootMessageId);
2508            }
2509    
2510            /**
2511            * Removes all the message boards threads where groupId = &#63; and categoryId = &#63; from the database.
2512            *
2513            * @param groupId the group ID
2514            * @param categoryId the category ID
2515            * @throws SystemException if a system exception occurred
2516            */
2517            public static void removeByG_C(long groupId, long categoryId)
2518                    throws com.liferay.portal.kernel.exception.SystemException {
2519                    getPersistence().removeByG_C(groupId, categoryId);
2520            }
2521    
2522            /**
2523            * Removes all the message boards threads where groupId = &#63; and categoryId &ne; &#63; from the database.
2524            *
2525            * @param groupId the group ID
2526            * @param categoryId the category ID
2527            * @throws SystemException if a system exception occurred
2528            */
2529            public static void removeByG_NotC(long groupId, long categoryId)
2530                    throws com.liferay.portal.kernel.exception.SystemException {
2531                    getPersistence().removeByG_NotC(groupId, categoryId);
2532            }
2533    
2534            /**
2535            * Removes all the message boards threads where groupId = &#63; and status = &#63; from the database.
2536            *
2537            * @param groupId the group ID
2538            * @param status the status
2539            * @throws SystemException if a system exception occurred
2540            */
2541            public static void removeByG_S(long groupId, int status)
2542                    throws com.liferay.portal.kernel.exception.SystemException {
2543                    getPersistence().removeByG_S(groupId, status);
2544            }
2545    
2546            /**
2547            * Removes all the message boards threads where categoryId = &#63; and priority = &#63; from the database.
2548            *
2549            * @param categoryId the category ID
2550            * @param priority the priority
2551            * @throws SystemException if a system exception occurred
2552            */
2553            public static void removeByC_P(long categoryId, double priority)
2554                    throws com.liferay.portal.kernel.exception.SystemException {
2555                    getPersistence().removeByC_P(categoryId, priority);
2556            }
2557    
2558            /**
2559            * Removes all the message boards threads where lastPostDate = &#63; and priority = &#63; from the database.
2560            *
2561            * @param lastPostDate the last post date
2562            * @param priority the priority
2563            * @throws SystemException if a system exception occurred
2564            */
2565            public static void removeByL_P(java.util.Date lastPostDate, double priority)
2566                    throws com.liferay.portal.kernel.exception.SystemException {
2567                    getPersistence().removeByL_P(lastPostDate, priority);
2568            }
2569    
2570            /**
2571            * Removes all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63; from the database.
2572            *
2573            * @param groupId the group ID
2574            * @param categoryId the category ID
2575            * @param lastPostDate the last post date
2576            * @throws SystemException if a system exception occurred
2577            */
2578            public static void removeByG_C_L(long groupId, long categoryId,
2579                    java.util.Date lastPostDate)
2580                    throws com.liferay.portal.kernel.exception.SystemException {
2581                    getPersistence().removeByG_C_L(groupId, categoryId, lastPostDate);
2582            }
2583    
2584            /**
2585            * Removes all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63; from the database.
2586            *
2587            * @param groupId the group ID
2588            * @param categoryId the category ID
2589            * @param status the status
2590            * @throws SystemException if a system exception occurred
2591            */
2592            public static void removeByG_C_S(long groupId, long categoryId, int status)
2593                    throws com.liferay.portal.kernel.exception.SystemException {
2594                    getPersistence().removeByG_C_S(groupId, categoryId, status);
2595            }
2596    
2597            /**
2598            * Removes all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63; from the database.
2599            *
2600            * @param groupId the group ID
2601            * @param categoryId the category ID
2602            * @param status the status
2603            * @throws SystemException if a system exception occurred
2604            */
2605            public static void removeByG_NotC_S(long groupId, long categoryId,
2606                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2607                    getPersistence().removeByG_NotC_S(groupId, categoryId, status);
2608            }
2609    
2610            /**
2611            * Removes all the message boards threads from the database.
2612            *
2613            * @throws SystemException if a system exception occurred
2614            */
2615            public static void removeAll()
2616                    throws com.liferay.portal.kernel.exception.SystemException {
2617                    getPersistence().removeAll();
2618            }
2619    
2620            /**
2621            * Returns the number of message boards threads where groupId = &#63;.
2622            *
2623            * @param groupId the group ID
2624            * @return the number of matching message boards threads
2625            * @throws SystemException if a system exception occurred
2626            */
2627            public static int countByGroupId(long groupId)
2628                    throws com.liferay.portal.kernel.exception.SystemException {
2629                    return getPersistence().countByGroupId(groupId);
2630            }
2631    
2632            /**
2633            * Returns the number of message boards threads that the user has permission to view where groupId = &#63;.
2634            *
2635            * @param groupId the group ID
2636            * @return the number of matching message boards threads that the user has permission to view
2637            * @throws SystemException if a system exception occurred
2638            */
2639            public static int filterCountByGroupId(long groupId)
2640                    throws com.liferay.portal.kernel.exception.SystemException {
2641                    return getPersistence().filterCountByGroupId(groupId);
2642            }
2643    
2644            /**
2645            * Returns the number of message boards threads where rootMessageId = &#63;.
2646            *
2647            * @param rootMessageId the root message ID
2648            * @return the number of matching message boards threads
2649            * @throws SystemException if a system exception occurred
2650            */
2651            public static int countByRootMessageId(long rootMessageId)
2652                    throws com.liferay.portal.kernel.exception.SystemException {
2653                    return getPersistence().countByRootMessageId(rootMessageId);
2654            }
2655    
2656            /**
2657            * Returns the number of message boards threads where groupId = &#63; and categoryId = &#63;.
2658            *
2659            * @param groupId the group ID
2660            * @param categoryId the category ID
2661            * @return the number of matching message boards threads
2662            * @throws SystemException if a system exception occurred
2663            */
2664            public static int countByG_C(long groupId, long categoryId)
2665                    throws com.liferay.portal.kernel.exception.SystemException {
2666                    return getPersistence().countByG_C(groupId, categoryId);
2667            }
2668    
2669            /**
2670            * Returns the number of message boards threads where groupId = &#63; and categoryId = any &#63;.
2671            *
2672            * @param groupId the group ID
2673            * @param categoryIds the category IDs
2674            * @return the number of matching message boards threads
2675            * @throws SystemException if a system exception occurred
2676            */
2677            public static int countByG_C(long groupId, long[] categoryIds)
2678                    throws com.liferay.portal.kernel.exception.SystemException {
2679                    return getPersistence().countByG_C(groupId, categoryIds);
2680            }
2681    
2682            /**
2683            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63;.
2684            *
2685            * @param groupId the group ID
2686            * @param categoryId the category ID
2687            * @return the number of matching message boards threads that the user has permission to view
2688            * @throws SystemException if a system exception occurred
2689            */
2690            public static int filterCountByG_C(long groupId, long categoryId)
2691                    throws com.liferay.portal.kernel.exception.SystemException {
2692                    return getPersistence().filterCountByG_C(groupId, categoryId);
2693            }
2694    
2695            /**
2696            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63;.
2697            *
2698            * @param groupId the group ID
2699            * @param categoryIds the category IDs
2700            * @return the number of matching message boards threads that the user has permission to view
2701            * @throws SystemException if a system exception occurred
2702            */
2703            public static int filterCountByG_C(long groupId, long[] categoryIds)
2704                    throws com.liferay.portal.kernel.exception.SystemException {
2705                    return getPersistence().filterCountByG_C(groupId, categoryIds);
2706            }
2707    
2708            /**
2709            * Returns the number of message boards threads where groupId = &#63; and categoryId &ne; &#63;.
2710            *
2711            * @param groupId the group ID
2712            * @param categoryId the category ID
2713            * @return the number of matching message boards threads
2714            * @throws SystemException if a system exception occurred
2715            */
2716            public static int countByG_NotC(long groupId, long categoryId)
2717                    throws com.liferay.portal.kernel.exception.SystemException {
2718                    return getPersistence().countByG_NotC(groupId, categoryId);
2719            }
2720    
2721            /**
2722            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63;.
2723            *
2724            * @param groupId the group ID
2725            * @param categoryId the category ID
2726            * @return the number of matching message boards threads that the user has permission to view
2727            * @throws SystemException if a system exception occurred
2728            */
2729            public static int filterCountByG_NotC(long groupId, long categoryId)
2730                    throws com.liferay.portal.kernel.exception.SystemException {
2731                    return getPersistence().filterCountByG_NotC(groupId, categoryId);
2732            }
2733    
2734            /**
2735            * Returns the number of message boards threads where groupId = &#63; and status = &#63;.
2736            *
2737            * @param groupId the group ID
2738            * @param status the status
2739            * @return the number of matching message boards threads
2740            * @throws SystemException if a system exception occurred
2741            */
2742            public static int countByG_S(long groupId, int status)
2743                    throws com.liferay.portal.kernel.exception.SystemException {
2744                    return getPersistence().countByG_S(groupId, status);
2745            }
2746    
2747            /**
2748            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and status = &#63;.
2749            *
2750            * @param groupId the group ID
2751            * @param status the status
2752            * @return the number of matching message boards threads that the user has permission to view
2753            * @throws SystemException if a system exception occurred
2754            */
2755            public static int filterCountByG_S(long groupId, int status)
2756                    throws com.liferay.portal.kernel.exception.SystemException {
2757                    return getPersistence().filterCountByG_S(groupId, status);
2758            }
2759    
2760            /**
2761            * Returns the number of message boards threads where categoryId = &#63; and priority = &#63;.
2762            *
2763            * @param categoryId the category ID
2764            * @param priority the priority
2765            * @return the number of matching message boards threads
2766            * @throws SystemException if a system exception occurred
2767            */
2768            public static int countByC_P(long categoryId, double priority)
2769                    throws com.liferay.portal.kernel.exception.SystemException {
2770                    return getPersistence().countByC_P(categoryId, priority);
2771            }
2772    
2773            /**
2774            * Returns the number of message boards threads where lastPostDate = &#63; and priority = &#63;.
2775            *
2776            * @param lastPostDate the last post date
2777            * @param priority the priority
2778            * @return the number of matching message boards threads
2779            * @throws SystemException if a system exception occurred
2780            */
2781            public static int countByL_P(java.util.Date lastPostDate, double priority)
2782                    throws com.liferay.portal.kernel.exception.SystemException {
2783                    return getPersistence().countByL_P(lastPostDate, priority);
2784            }
2785    
2786            /**
2787            * Returns the number of message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2788            *
2789            * @param groupId the group ID
2790            * @param categoryId the category ID
2791            * @param lastPostDate the last post date
2792            * @return the number of matching message boards threads
2793            * @throws SystemException if a system exception occurred
2794            */
2795            public static int countByG_C_L(long groupId, long categoryId,
2796                    java.util.Date lastPostDate)
2797                    throws com.liferay.portal.kernel.exception.SystemException {
2798                    return getPersistence().countByG_C_L(groupId, categoryId, lastPostDate);
2799            }
2800    
2801            /**
2802            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2803            *
2804            * @param groupId the group ID
2805            * @param categoryId the category ID
2806            * @param lastPostDate the last post date
2807            * @return the number of matching message boards threads that the user has permission to view
2808            * @throws SystemException if a system exception occurred
2809            */
2810            public static int filterCountByG_C_L(long groupId, long categoryId,
2811                    java.util.Date lastPostDate)
2812                    throws com.liferay.portal.kernel.exception.SystemException {
2813                    return getPersistence()
2814                                       .filterCountByG_C_L(groupId, categoryId, lastPostDate);
2815            }
2816    
2817            /**
2818            * Returns the number of message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
2819            *
2820            * @param groupId the group ID
2821            * @param categoryId the category ID
2822            * @param status the status
2823            * @return the number of matching message boards threads
2824            * @throws SystemException if a system exception occurred
2825            */
2826            public static int countByG_C_S(long groupId, long categoryId, int status)
2827                    throws com.liferay.portal.kernel.exception.SystemException {
2828                    return getPersistence().countByG_C_S(groupId, categoryId, status);
2829            }
2830    
2831            /**
2832            * Returns the number of message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2833            *
2834            * @param groupId the group ID
2835            * @param categoryIds the category IDs
2836            * @param status the status
2837            * @return the number of matching message boards threads
2838            * @throws SystemException if a system exception occurred
2839            */
2840            public static int countByG_C_S(long groupId, long[] categoryIds, int status)
2841                    throws com.liferay.portal.kernel.exception.SystemException {
2842                    return getPersistence().countByG_C_S(groupId, categoryIds, status);
2843            }
2844    
2845            /**
2846            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
2847            *
2848            * @param groupId the group ID
2849            * @param categoryId the category ID
2850            * @param status the status
2851            * @return the number of matching message boards threads that the user has permission to view
2852            * @throws SystemException if a system exception occurred
2853            */
2854            public static int filterCountByG_C_S(long groupId, long categoryId,
2855                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2856                    return getPersistence().filterCountByG_C_S(groupId, categoryId, status);
2857            }
2858    
2859            /**
2860            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2861            *
2862            * @param groupId the group ID
2863            * @param categoryIds the category IDs
2864            * @param status the status
2865            * @return the number of matching message boards threads that the user has permission to view
2866            * @throws SystemException if a system exception occurred
2867            */
2868            public static int filterCountByG_C_S(long groupId, long[] categoryIds,
2869                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2870                    return getPersistence().filterCountByG_C_S(groupId, categoryIds, status);
2871            }
2872    
2873            /**
2874            * Returns the number of message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2875            *
2876            * @param groupId the group ID
2877            * @param categoryId the category ID
2878            * @param status the status
2879            * @return the number of matching message boards threads
2880            * @throws SystemException if a system exception occurred
2881            */
2882            public static int countByG_NotC_S(long groupId, long categoryId, int status)
2883                    throws com.liferay.portal.kernel.exception.SystemException {
2884                    return getPersistence().countByG_NotC_S(groupId, categoryId, status);
2885            }
2886    
2887            /**
2888            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
2889            *
2890            * @param groupId the group ID
2891            * @param categoryId the category ID
2892            * @param status the status
2893            * @return the number of matching message boards threads that the user has permission to view
2894            * @throws SystemException if a system exception occurred
2895            */
2896            public static int filterCountByG_NotC_S(long groupId, long categoryId,
2897                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2898                    return getPersistence()
2899                                       .filterCountByG_NotC_S(groupId, categoryId, status);
2900            }
2901    
2902            /**
2903            * Returns the number of message boards threads.
2904            *
2905            * @return the number of message boards threads
2906            * @throws SystemException if a system exception occurred
2907            */
2908            public static int countAll()
2909                    throws com.liferay.portal.kernel.exception.SystemException {
2910                    return getPersistence().countAll();
2911            }
2912    
2913            public static MBThreadPersistence getPersistence() {
2914                    if (_persistence == null) {
2915                            _persistence = (MBThreadPersistence)PortalBeanLocatorUtil.locate(MBThreadPersistence.class.getName());
2916    
2917                            ReferenceRegistry.registerReference(MBThreadUtil.class,
2918                                    "_persistence");
2919                    }
2920    
2921                    return _persistence;
2922            }
2923    
2924            /**
2925             * @deprecated
2926             */
2927            public void setPersistence(MBThreadPersistence persistence) {
2928            }
2929    
2930            private static MBThreadPersistence _persistence;
2931    }