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