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