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