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