001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.messageboards.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.messageboards.model.MBThread;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the message boards thread service. This utility wraps {@link MBThreadPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see MBThreadPersistence
037     * @see MBThreadPersistenceImpl
038     * @generated
039     */
040    public class MBThreadUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(MBThread mbThread) {
058                    getPersistence().clearCache(mbThread);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<MBThread> findWithDynamicQuery(DynamicQuery dynamicQuery)
073                    throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<MBThread> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<MBThread> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static MBThread update(MBThread mbThread) throws SystemException {
101                    return getPersistence().update(mbThread);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static MBThread update(MBThread mbThread,
108                    ServiceContext serviceContext) throws SystemException {
109                    return getPersistence().update(mbThread, serviceContext);
110            }
111    
112            /**
113            * Returns all the message boards threads where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching message boards threads
117            * @throws SystemException if a system exception occurred
118            */
119            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid(
120                    java.lang.String uuid)
121                    throws com.liferay.portal.kernel.exception.SystemException {
122                    return getPersistence().findByUuid(uuid);
123            }
124    
125            /**
126            * Returns a range of all the message boards threads where uuid = &#63;.
127            *
128            * <p>
129            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
130            * </p>
131            *
132            * @param uuid the uuid
133            * @param start the lower bound of the range of message boards threads
134            * @param end the upper bound of the range of message boards threads (not inclusive)
135            * @return the range of matching message boards threads
136            * @throws SystemException if a system exception occurred
137            */
138            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid(
139                    java.lang.String uuid, int start, int end)
140                    throws com.liferay.portal.kernel.exception.SystemException {
141                    return getPersistence().findByUuid(uuid, start, end);
142            }
143    
144            /**
145            * Returns an ordered range of all the message boards threads where uuid = &#63;.
146            *
147            * <p>
148            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
149            * </p>
150            *
151            * @param uuid the uuid
152            * @param start the lower bound of the range of message boards threads
153            * @param end the upper bound of the range of message boards threads (not inclusive)
154            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
155            * @return the ordered range of matching message boards threads
156            * @throws SystemException if a system exception occurred
157            */
158            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid(
159                    java.lang.String uuid, int start, int end,
160                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
161                    throws com.liferay.portal.kernel.exception.SystemException {
162                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
163            }
164    
165            /**
166            * Returns the first message boards thread in the ordered set where uuid = &#63;.
167            *
168            * @param uuid the uuid
169            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
170            * @return the first matching message boards thread
171            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
172            * @throws SystemException if a system exception occurred
173            */
174            public static com.liferay.portlet.messageboards.model.MBThread findByUuid_First(
175                    java.lang.String uuid,
176                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
177                    throws com.liferay.portal.kernel.exception.SystemException,
178                            com.liferay.portlet.messageboards.NoSuchThreadException {
179                    return getPersistence().findByUuid_First(uuid, orderByComparator);
180            }
181    
182            /**
183            * Returns the first message boards thread in the ordered set where uuid = &#63;.
184            *
185            * @param uuid the uuid
186            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
187            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
188            * @throws SystemException if a system exception occurred
189            */
190            public static com.liferay.portlet.messageboards.model.MBThread fetchByUuid_First(
191                    java.lang.String uuid,
192                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
193                    throws com.liferay.portal.kernel.exception.SystemException {
194                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last message boards thread in the ordered set where uuid = &#63;.
199            *
200            * @param uuid the uuid
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching message boards thread
203            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
204            * @throws SystemException if a system exception occurred
205            */
206            public static com.liferay.portlet.messageboards.model.MBThread findByUuid_Last(
207                    java.lang.String uuid,
208                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
209                    throws com.liferay.portal.kernel.exception.SystemException,
210                            com.liferay.portlet.messageboards.NoSuchThreadException {
211                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
212            }
213    
214            /**
215            * Returns the last message boards thread in the ordered set where uuid = &#63;.
216            *
217            * @param uuid the uuid
218            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
219            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
220            * @throws SystemException if a system exception occurred
221            */
222            public static com.liferay.portlet.messageboards.model.MBThread fetchByUuid_Last(
223                    java.lang.String uuid,
224                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
225                    throws com.liferay.portal.kernel.exception.SystemException {
226                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
227            }
228    
229            /**
230            * Returns the message boards threads before and after the current message boards thread in the ordered set where uuid = &#63;.
231            *
232            * @param threadId the primary key of the current message boards thread
233            * @param uuid the uuid
234            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
235            * @return the previous, current, and next message boards thread
236            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
237            * @throws SystemException if a system exception occurred
238            */
239            public static com.liferay.portlet.messageboards.model.MBThread[] findByUuid_PrevAndNext(
240                    long threadId, java.lang.String uuid,
241                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
242                    throws com.liferay.portal.kernel.exception.SystemException,
243                            com.liferay.portlet.messageboards.NoSuchThreadException {
244                    return getPersistence()
245                                       .findByUuid_PrevAndNext(threadId, uuid, orderByComparator);
246            }
247    
248            /**
249            * Removes all the message boards threads where uuid = &#63; from the database.
250            *
251            * @param uuid the uuid
252            * @throws SystemException if a system exception occurred
253            */
254            public static void removeByUuid(java.lang.String uuid)
255                    throws com.liferay.portal.kernel.exception.SystemException {
256                    getPersistence().removeByUuid(uuid);
257            }
258    
259            /**
260            * Returns the number of message boards threads where uuid = &#63;.
261            *
262            * @param uuid the uuid
263            * @return the number of matching message boards threads
264            * @throws SystemException if a system exception occurred
265            */
266            public static int countByUuid(java.lang.String uuid)
267                    throws com.liferay.portal.kernel.exception.SystemException {
268                    return getPersistence().countByUuid(uuid);
269            }
270    
271            /**
272            * Returns the message boards thread where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found.
273            *
274            * @param uuid the uuid
275            * @param groupId the group ID
276            * @return the matching message boards thread
277            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
278            * @throws SystemException if a system exception occurred
279            */
280            public static com.liferay.portlet.messageboards.model.MBThread findByUUID_G(
281                    java.lang.String uuid, long groupId)
282                    throws com.liferay.portal.kernel.exception.SystemException,
283                            com.liferay.portlet.messageboards.NoSuchThreadException {
284                    return getPersistence().findByUUID_G(uuid, groupId);
285            }
286    
287            /**
288            * Returns the message boards thread where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
289            *
290            * @param uuid the uuid
291            * @param groupId the group ID
292            * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
293            * @throws SystemException if a system exception occurred
294            */
295            public static com.liferay.portlet.messageboards.model.MBThread fetchByUUID_G(
296                    java.lang.String uuid, long groupId)
297                    throws com.liferay.portal.kernel.exception.SystemException {
298                    return getPersistence().fetchByUUID_G(uuid, groupId);
299            }
300    
301            /**
302            * Returns the message boards thread where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
303            *
304            * @param uuid the uuid
305            * @param groupId the group ID
306            * @param retrieveFromCache whether to use the finder cache
307            * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
308            * @throws SystemException if a system exception occurred
309            */
310            public static com.liferay.portlet.messageboards.model.MBThread fetchByUUID_G(
311                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
312                    throws com.liferay.portal.kernel.exception.SystemException {
313                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
314            }
315    
316            /**
317            * Removes the message boards thread where uuid = &#63; and groupId = &#63; from the database.
318            *
319            * @param uuid the uuid
320            * @param groupId the group ID
321            * @return the message boards thread that was removed
322            * @throws SystemException if a system exception occurred
323            */
324            public static com.liferay.portlet.messageboards.model.MBThread removeByUUID_G(
325                    java.lang.String uuid, long groupId)
326                    throws com.liferay.portal.kernel.exception.SystemException,
327                            com.liferay.portlet.messageboards.NoSuchThreadException {
328                    return getPersistence().removeByUUID_G(uuid, groupId);
329            }
330    
331            /**
332            * Returns the number of message boards threads where uuid = &#63; and groupId = &#63;.
333            *
334            * @param uuid the uuid
335            * @param groupId the group ID
336            * @return the number of matching message boards threads
337            * @throws SystemException if a system exception occurred
338            */
339            public static int countByUUID_G(java.lang.String uuid, long groupId)
340                    throws com.liferay.portal.kernel.exception.SystemException {
341                    return getPersistence().countByUUID_G(uuid, groupId);
342            }
343    
344            /**
345            * Returns all the message boards threads where uuid = &#63; and companyId = &#63;.
346            *
347            * @param uuid the uuid
348            * @param companyId the company ID
349            * @return the matching message boards threads
350            * @throws SystemException if a system exception occurred
351            */
352            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid_C(
353                    java.lang.String uuid, long companyId)
354                    throws com.liferay.portal.kernel.exception.SystemException {
355                    return getPersistence().findByUuid_C(uuid, companyId);
356            }
357    
358            /**
359            * Returns a range of all the message boards threads where uuid = &#63; and companyId = &#63;.
360            *
361            * <p>
362            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
363            * </p>
364            *
365            * @param uuid the uuid
366            * @param companyId the company ID
367            * @param start the lower bound of the range of message boards threads
368            * @param end the upper bound of the range of message boards threads (not inclusive)
369            * @return the range of matching message boards threads
370            * @throws SystemException if a system exception occurred
371            */
372            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid_C(
373                    java.lang.String uuid, long companyId, int start, int end)
374                    throws com.liferay.portal.kernel.exception.SystemException {
375                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
376            }
377    
378            /**
379            * Returns an ordered range of all the message boards threads where uuid = &#63; and companyId = &#63;.
380            *
381            * <p>
382            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
383            * </p>
384            *
385            * @param uuid the uuid
386            * @param companyId the company ID
387            * @param start the lower bound of the range of message boards threads
388            * @param end the upper bound of the range of message boards threads (not inclusive)
389            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
390            * @return the ordered range of matching message boards threads
391            * @throws SystemException if a system exception occurred
392            */
393            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByUuid_C(
394                    java.lang.String uuid, long companyId, int start, int end,
395                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
396                    throws com.liferay.portal.kernel.exception.SystemException {
397                    return getPersistence()
398                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
399            }
400    
401            /**
402            * Returns the first message boards thread in the ordered set where uuid = &#63; and companyId = &#63;.
403            *
404            * @param uuid the uuid
405            * @param companyId the company ID
406            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
407            * @return the first matching message boards thread
408            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
409            * @throws SystemException if a system exception occurred
410            */
411            public static com.liferay.portlet.messageboards.model.MBThread findByUuid_C_First(
412                    java.lang.String uuid, long companyId,
413                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
414                    throws com.liferay.portal.kernel.exception.SystemException,
415                            com.liferay.portlet.messageboards.NoSuchThreadException {
416                    return getPersistence()
417                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
418            }
419    
420            /**
421            * Returns the first message boards thread in the ordered set where uuid = &#63; and companyId = &#63;.
422            *
423            * @param uuid the uuid
424            * @param companyId the company ID
425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
426            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
427            * @throws SystemException if a system exception occurred
428            */
429            public static com.liferay.portlet.messageboards.model.MBThread fetchByUuid_C_First(
430                    java.lang.String uuid, long companyId,
431                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
432                    throws com.liferay.portal.kernel.exception.SystemException {
433                    return getPersistence()
434                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
435            }
436    
437            /**
438            * Returns the last message boards thread in the ordered set where uuid = &#63; and companyId = &#63;.
439            *
440            * @param uuid the uuid
441            * @param companyId the company ID
442            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
443            * @return the last matching message boards thread
444            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
445            * @throws SystemException if a system exception occurred
446            */
447            public static com.liferay.portlet.messageboards.model.MBThread findByUuid_C_Last(
448                    java.lang.String uuid, long companyId,
449                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
450                    throws com.liferay.portal.kernel.exception.SystemException,
451                            com.liferay.portlet.messageboards.NoSuchThreadException {
452                    return getPersistence()
453                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
454            }
455    
456            /**
457            * Returns the last message boards thread in the ordered set where uuid = &#63; and companyId = &#63;.
458            *
459            * @param uuid the uuid
460            * @param companyId the company ID
461            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
462            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
463            * @throws SystemException if a system exception occurred
464            */
465            public static com.liferay.portlet.messageboards.model.MBThread fetchByUuid_C_Last(
466                    java.lang.String uuid, long companyId,
467                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
468                    throws com.liferay.portal.kernel.exception.SystemException {
469                    return getPersistence()
470                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
471            }
472    
473            /**
474            * Returns the message boards threads before and after the current message boards thread in the ordered set where uuid = &#63; and companyId = &#63;.
475            *
476            * @param threadId the primary key of the current message boards thread
477            * @param uuid the uuid
478            * @param companyId the company ID
479            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
480            * @return the previous, current, and next message boards thread
481            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
482            * @throws SystemException if a system exception occurred
483            */
484            public static com.liferay.portlet.messageboards.model.MBThread[] findByUuid_C_PrevAndNext(
485                    long threadId, java.lang.String uuid, long companyId,
486                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
487                    throws com.liferay.portal.kernel.exception.SystemException,
488                            com.liferay.portlet.messageboards.NoSuchThreadException {
489                    return getPersistence()
490                                       .findByUuid_C_PrevAndNext(threadId, uuid, companyId,
491                            orderByComparator);
492            }
493    
494            /**
495            * Removes all the message boards threads where uuid = &#63; and companyId = &#63; from the database.
496            *
497            * @param uuid the uuid
498            * @param companyId the company ID
499            * @throws SystemException if a system exception occurred
500            */
501            public static void removeByUuid_C(java.lang.String uuid, long companyId)
502                    throws com.liferay.portal.kernel.exception.SystemException {
503                    getPersistence().removeByUuid_C(uuid, companyId);
504            }
505    
506            /**
507            * Returns the number of message boards threads where uuid = &#63; and companyId = &#63;.
508            *
509            * @param uuid the uuid
510            * @param companyId the company ID
511            * @return the number of matching message boards threads
512            * @throws SystemException if a system exception occurred
513            */
514            public static int countByUuid_C(java.lang.String uuid, long companyId)
515                    throws com.liferay.portal.kernel.exception.SystemException {
516                    return getPersistence().countByUuid_C(uuid, companyId);
517            }
518    
519            /**
520            * Returns all the message boards threads where groupId = &#63;.
521            *
522            * @param groupId the group ID
523            * @return the matching message boards threads
524            * @throws SystemException if a system exception occurred
525            */
526            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId(
527                    long groupId)
528                    throws com.liferay.portal.kernel.exception.SystemException {
529                    return getPersistence().findByGroupId(groupId);
530            }
531    
532            /**
533            * Returns a range of all the message boards threads where groupId = &#63;.
534            *
535            * <p>
536            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
537            * </p>
538            *
539            * @param groupId the group ID
540            * @param start the lower bound of the range of message boards threads
541            * @param end the upper bound of the range of message boards threads (not inclusive)
542            * @return the range of matching message boards threads
543            * @throws SystemException if a system exception occurred
544            */
545            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId(
546                    long groupId, int start, int end)
547                    throws com.liferay.portal.kernel.exception.SystemException {
548                    return getPersistence().findByGroupId(groupId, start, end);
549            }
550    
551            /**
552            * Returns an ordered range of all the message boards threads where groupId = &#63;.
553            *
554            * <p>
555            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
556            * </p>
557            *
558            * @param groupId the group ID
559            * @param start the lower bound of the range of message boards threads
560            * @param end the upper bound of the range of message boards threads (not inclusive)
561            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
562            * @return the ordered range of matching message boards threads
563            * @throws SystemException if a system exception occurred
564            */
565            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByGroupId(
566                    long groupId, int start, int end,
567                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
568                    throws com.liferay.portal.kernel.exception.SystemException {
569                    return getPersistence()
570                                       .findByGroupId(groupId, start, end, orderByComparator);
571            }
572    
573            /**
574            * Returns the first message boards thread in the ordered set where groupId = &#63;.
575            *
576            * @param groupId the group ID
577            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
578            * @return the first matching message boards thread
579            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
580            * @throws SystemException if a system exception occurred
581            */
582            public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_First(
583                    long groupId,
584                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
585                    throws com.liferay.portal.kernel.exception.SystemException,
586                            com.liferay.portlet.messageboards.NoSuchThreadException {
587                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
588            }
589    
590            /**
591            * Returns the first message boards thread in the ordered set where groupId = &#63;.
592            *
593            * @param groupId the group ID
594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
595            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
596            * @throws SystemException if a system exception occurred
597            */
598            public static com.liferay.portlet.messageboards.model.MBThread fetchByGroupId_First(
599                    long groupId,
600                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
601                    throws com.liferay.portal.kernel.exception.SystemException {
602                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
603            }
604    
605            /**
606            * Returns the last message boards thread in the ordered set where groupId = &#63;.
607            *
608            * @param groupId the group ID
609            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
610            * @return the last matching message boards thread
611            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
612            * @throws SystemException if a system exception occurred
613            */
614            public static com.liferay.portlet.messageboards.model.MBThread findByGroupId_Last(
615                    long groupId,
616                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
617                    throws com.liferay.portal.kernel.exception.SystemException,
618                            com.liferay.portlet.messageboards.NoSuchThreadException {
619                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
620            }
621    
622            /**
623            * Returns the last message boards thread in the ordered set where groupId = &#63;.
624            *
625            * @param groupId the group ID
626            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
627            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
628            * @throws SystemException if a system exception occurred
629            */
630            public static com.liferay.portlet.messageboards.model.MBThread fetchByGroupId_Last(
631                    long groupId,
632                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
633                    throws com.liferay.portal.kernel.exception.SystemException {
634                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
635            }
636    
637            /**
638            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63;.
639            *
640            * @param threadId the primary key of the current message boards thread
641            * @param groupId the group ID
642            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
643            * @return the previous, current, and next message boards thread
644            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
645            * @throws SystemException if a system exception occurred
646            */
647            public static com.liferay.portlet.messageboards.model.MBThread[] findByGroupId_PrevAndNext(
648                    long threadId, long groupId,
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                                       .findByGroupId_PrevAndNext(threadId, groupId,
654                            orderByComparator);
655            }
656    
657            /**
658            * Returns all the message boards threads that the user has permission to view where groupId = &#63;.
659            *
660            * @param groupId the group ID
661            * @return the matching message boards threads that the user has permission to view
662            * @throws SystemException if a system exception occurred
663            */
664            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId(
665                    long groupId)
666                    throws com.liferay.portal.kernel.exception.SystemException {
667                    return getPersistence().filterFindByGroupId(groupId);
668            }
669    
670            /**
671            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63;.
672            *
673            * <p>
674            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
675            * </p>
676            *
677            * @param groupId the group ID
678            * @param start the lower bound of the range of message boards threads
679            * @param end the upper bound of the range of message boards threads (not inclusive)
680            * @return the range of matching message boards threads that the user has permission to view
681            * @throws SystemException if a system exception occurred
682            */
683            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId(
684                    long groupId, int start, int end)
685                    throws com.liferay.portal.kernel.exception.SystemException {
686                    return getPersistence().filterFindByGroupId(groupId, start, end);
687            }
688    
689            /**
690            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63;.
691            *
692            * <p>
693            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
694            * </p>
695            *
696            * @param groupId the group ID
697            * @param start the lower bound of the range of message boards threads
698            * @param end the upper bound of the range of message boards threads (not inclusive)
699            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
700            * @return the ordered range of matching message boards threads that the user has permission to view
701            * @throws SystemException if a system exception occurred
702            */
703            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByGroupId(
704                    long groupId, int start, int end,
705                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
706                    throws com.liferay.portal.kernel.exception.SystemException {
707                    return getPersistence()
708                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
709            }
710    
711            /**
712            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63;.
713            *
714            * @param threadId the primary key of the current message boards thread
715            * @param groupId the group ID
716            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
717            * @return the previous, current, and next message boards thread
718            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
719            * @throws SystemException if a system exception occurred
720            */
721            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByGroupId_PrevAndNext(
722                    long threadId, long groupId,
723                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
724                    throws com.liferay.portal.kernel.exception.SystemException,
725                            com.liferay.portlet.messageboards.NoSuchThreadException {
726                    return getPersistence()
727                                       .filterFindByGroupId_PrevAndNext(threadId, groupId,
728                            orderByComparator);
729            }
730    
731            /**
732            * Removes all the message boards threads where groupId = &#63; from the database.
733            *
734            * @param groupId the group ID
735            * @throws SystemException if a system exception occurred
736            */
737            public static void removeByGroupId(long groupId)
738                    throws com.liferay.portal.kernel.exception.SystemException {
739                    getPersistence().removeByGroupId(groupId);
740            }
741    
742            /**
743            * Returns the number of message boards threads where groupId = &#63;.
744            *
745            * @param groupId the group ID
746            * @return the number of matching message boards threads
747            * @throws SystemException if a system exception occurred
748            */
749            public static int countByGroupId(long groupId)
750                    throws com.liferay.portal.kernel.exception.SystemException {
751                    return getPersistence().countByGroupId(groupId);
752            }
753    
754            /**
755            * Returns the number of message boards threads that the user has permission to view where groupId = &#63;.
756            *
757            * @param groupId the group ID
758            * @return the number of matching message boards threads that the user has permission to view
759            * @throws SystemException if a system exception occurred
760            */
761            public static int filterCountByGroupId(long groupId)
762                    throws com.liferay.portal.kernel.exception.SystemException {
763                    return getPersistence().filterCountByGroupId(groupId);
764            }
765    
766            /**
767            * Returns the message boards thread where rootMessageId = &#63; or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found.
768            *
769            * @param rootMessageId the root message ID
770            * @return the matching message boards thread
771            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
772            * @throws SystemException if a system exception occurred
773            */
774            public static com.liferay.portlet.messageboards.model.MBThread findByRootMessageId(
775                    long rootMessageId)
776                    throws com.liferay.portal.kernel.exception.SystemException,
777                            com.liferay.portlet.messageboards.NoSuchThreadException {
778                    return getPersistence().findByRootMessageId(rootMessageId);
779            }
780    
781            /**
782            * Returns the message boards thread where rootMessageId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
783            *
784            * @param rootMessageId the root message ID
785            * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
786            * @throws SystemException if a system exception occurred
787            */
788            public static com.liferay.portlet.messageboards.model.MBThread fetchByRootMessageId(
789                    long rootMessageId)
790                    throws com.liferay.portal.kernel.exception.SystemException {
791                    return getPersistence().fetchByRootMessageId(rootMessageId);
792            }
793    
794            /**
795            * Returns the message boards thread where rootMessageId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
796            *
797            * @param rootMessageId the root message ID
798            * @param retrieveFromCache whether to use the finder cache
799            * @return the matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
800            * @throws SystemException if a system exception occurred
801            */
802            public static com.liferay.portlet.messageboards.model.MBThread fetchByRootMessageId(
803                    long rootMessageId, boolean retrieveFromCache)
804                    throws com.liferay.portal.kernel.exception.SystemException {
805                    return getPersistence()
806                                       .fetchByRootMessageId(rootMessageId, retrieveFromCache);
807            }
808    
809            /**
810            * Removes the message boards thread where rootMessageId = &#63; from the database.
811            *
812            * @param rootMessageId the root message ID
813            * @return the message boards thread that was removed
814            * @throws SystemException if a system exception occurred
815            */
816            public static com.liferay.portlet.messageboards.model.MBThread removeByRootMessageId(
817                    long rootMessageId)
818                    throws com.liferay.portal.kernel.exception.SystemException,
819                            com.liferay.portlet.messageboards.NoSuchThreadException {
820                    return getPersistence().removeByRootMessageId(rootMessageId);
821            }
822    
823            /**
824            * Returns the number of message boards threads where rootMessageId = &#63;.
825            *
826            * @param rootMessageId the root message ID
827            * @return the number of matching message boards threads
828            * @throws SystemException if a system exception occurred
829            */
830            public static int countByRootMessageId(long rootMessageId)
831                    throws com.liferay.portal.kernel.exception.SystemException {
832                    return getPersistence().countByRootMessageId(rootMessageId);
833            }
834    
835            /**
836            * Returns all the message boards threads where groupId = &#63; and categoryId = &#63;.
837            *
838            * @param groupId the group ID
839            * @param categoryId the category ID
840            * @return the matching message boards threads
841            * @throws SystemException if a system exception occurred
842            */
843            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
844                    long groupId, long categoryId)
845                    throws com.liferay.portal.kernel.exception.SystemException {
846                    return getPersistence().findByG_C(groupId, categoryId);
847            }
848    
849            /**
850            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = &#63;.
851            *
852            * <p>
853            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
854            * </p>
855            *
856            * @param groupId the group ID
857            * @param categoryId the category ID
858            * @param start the lower bound of the range of message boards threads
859            * @param end the upper bound of the range of message boards threads (not inclusive)
860            * @return the range of matching message boards threads
861            * @throws SystemException if a system exception occurred
862            */
863            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
864                    long groupId, long categoryId, int start, int end)
865                    throws com.liferay.portal.kernel.exception.SystemException {
866                    return getPersistence().findByG_C(groupId, categoryId, start, end);
867            }
868    
869            /**
870            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = &#63;.
871            *
872            * <p>
873            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
874            * </p>
875            *
876            * @param groupId the group ID
877            * @param categoryId the category ID
878            * @param start the lower bound of the range of message boards threads
879            * @param end the upper bound of the range of message boards threads (not inclusive)
880            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
881            * @return the ordered range of matching message boards threads
882            * @throws SystemException if a system exception occurred
883            */
884            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
885                    long groupId, long categoryId, int start, int end,
886                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
887                    throws com.liferay.portal.kernel.exception.SystemException {
888                    return getPersistence()
889                                       .findByG_C(groupId, categoryId, start, end, orderByComparator);
890            }
891    
892            /**
893            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
894            *
895            * @param groupId the group ID
896            * @param categoryId the category ID
897            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
898            * @return the first matching message boards thread
899            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
900            * @throws SystemException if a system exception occurred
901            */
902            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_First(
903                    long groupId, long categoryId,
904                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
905                    throws com.liferay.portal.kernel.exception.SystemException,
906                            com.liferay.portlet.messageboards.NoSuchThreadException {
907                    return getPersistence()
908                                       .findByG_C_First(groupId, categoryId, orderByComparator);
909            }
910    
911            /**
912            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
913            *
914            * @param groupId the group ID
915            * @param categoryId the category ID
916            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
917            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
918            * @throws SystemException if a system exception occurred
919            */
920            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_First(
921                    long groupId, long categoryId,
922                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
923                    throws com.liferay.portal.kernel.exception.SystemException {
924                    return getPersistence()
925                                       .fetchByG_C_First(groupId, categoryId, orderByComparator);
926            }
927    
928            /**
929            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
930            *
931            * @param groupId the group ID
932            * @param categoryId the category ID
933            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
934            * @return the last matching message boards thread
935            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
936            * @throws SystemException if a system exception occurred
937            */
938            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_Last(
939                    long groupId, long categoryId,
940                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
941                    throws com.liferay.portal.kernel.exception.SystemException,
942                            com.liferay.portlet.messageboards.NoSuchThreadException {
943                    return getPersistence()
944                                       .findByG_C_Last(groupId, categoryId, orderByComparator);
945            }
946    
947            /**
948            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
949            *
950            * @param groupId the group ID
951            * @param categoryId the category ID
952            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
953            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
954            * @throws SystemException if a system exception occurred
955            */
956            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_Last(
957                    long groupId, long categoryId,
958                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
959                    throws com.liferay.portal.kernel.exception.SystemException {
960                    return getPersistence()
961                                       .fetchByG_C_Last(groupId, categoryId, orderByComparator);
962            }
963    
964            /**
965            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId = &#63;.
966            *
967            * @param threadId the primary key of the current message boards thread
968            * @param groupId the group ID
969            * @param categoryId the category ID
970            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
971            * @return the previous, current, and next message boards thread
972            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
973            * @throws SystemException if a system exception occurred
974            */
975            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_PrevAndNext(
976                    long threadId, long groupId, long categoryId,
977                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
978                    throws com.liferay.portal.kernel.exception.SystemException,
979                            com.liferay.portlet.messageboards.NoSuchThreadException {
980                    return getPersistence()
981                                       .findByG_C_PrevAndNext(threadId, groupId, categoryId,
982                            orderByComparator);
983            }
984    
985            /**
986            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63;.
987            *
988            * @param groupId the group ID
989            * @param categoryId the category ID
990            * @return the matching message boards threads that the user has permission to view
991            * @throws SystemException if a system exception occurred
992            */
993            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
994                    long groupId, long categoryId)
995                    throws com.liferay.portal.kernel.exception.SystemException {
996                    return getPersistence().filterFindByG_C(groupId, categoryId);
997            }
998    
999            /**
1000            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63;.
1001            *
1002            * <p>
1003            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1004            * </p>
1005            *
1006            * @param groupId the group ID
1007            * @param categoryId the category ID
1008            * @param start the lower bound of the range of message boards threads
1009            * @param end the upper bound of the range of message boards threads (not inclusive)
1010            * @return the range of matching message boards threads that the user has permission to view
1011            * @throws SystemException if a system exception occurred
1012            */
1013            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
1014                    long groupId, long categoryId, int start, int end)
1015                    throws com.liferay.portal.kernel.exception.SystemException {
1016                    return getPersistence().filterFindByG_C(groupId, categoryId, start, end);
1017            }
1018    
1019            /**
1020            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId = &#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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1024            * </p>
1025            *
1026            * @param groupId the group ID
1027            * @param categoryId the category ID
1028            * @param start the lower bound of the range of message boards threads
1029            * @param end the upper bound of the range of message boards threads (not inclusive)
1030            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1031            * @return the ordered range of matching message boards threads that the user has permission to view
1032            * @throws SystemException if a system exception occurred
1033            */
1034            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
1035                    long groupId, long categoryId, int start, int end,
1036                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1037                    throws com.liferay.portal.kernel.exception.SystemException {
1038                    return getPersistence()
1039                                       .filterFindByG_C(groupId, categoryId, start, end,
1040                            orderByComparator);
1041            }
1042    
1043            /**
1044            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63;.
1045            *
1046            * @param threadId the primary key of the current message boards thread
1047            * @param groupId the group ID
1048            * @param categoryId the category ID
1049            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1050            * @return the previous, current, and next message boards thread
1051            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1052            * @throws SystemException if a system exception occurred
1053            */
1054            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_PrevAndNext(
1055                    long threadId, long groupId, long categoryId,
1056                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1057                    throws com.liferay.portal.kernel.exception.SystemException,
1058                            com.liferay.portlet.messageboards.NoSuchThreadException {
1059                    return getPersistence()
1060                                       .filterFindByG_C_PrevAndNext(threadId, groupId, categoryId,
1061                            orderByComparator);
1062            }
1063    
1064            /**
1065            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63;.
1066            *
1067            * @param groupId the group ID
1068            * @param categoryIds the category IDs
1069            * @return the matching message boards threads that the user has permission to view
1070            * @throws SystemException if a system exception occurred
1071            */
1072            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
1073                    long groupId, long[] categoryIds)
1074                    throws com.liferay.portal.kernel.exception.SystemException {
1075                    return getPersistence().filterFindByG_C(groupId, categoryIds);
1076            }
1077    
1078            /**
1079            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63;.
1080            *
1081            * <p>
1082            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1083            * </p>
1084            *
1085            * @param groupId the group ID
1086            * @param categoryIds the category IDs
1087            * @param start the lower bound of the range of message boards threads
1088            * @param end the upper bound of the range of message boards threads (not inclusive)
1089            * @return the range of matching message boards threads that the user has permission to view
1090            * @throws SystemException if a system exception occurred
1091            */
1092            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
1093                    long groupId, long[] categoryIds, int start, int end)
1094                    throws com.liferay.portal.kernel.exception.SystemException {
1095                    return getPersistence().filterFindByG_C(groupId, categoryIds, start, end);
1096            }
1097    
1098            /**
1099            * Returns an ordered range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63;.
1100            *
1101            * <p>
1102            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1103            * </p>
1104            *
1105            * @param groupId the group ID
1106            * @param categoryIds the category IDs
1107            * @param start the lower bound of the range of message boards threads
1108            * @param end the upper bound of the range of message boards threads (not inclusive)
1109            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1110            * @return the ordered range of matching message boards threads that the user has permission to view
1111            * @throws SystemException if a system exception occurred
1112            */
1113            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C(
1114                    long groupId, long[] categoryIds, int start, int end,
1115                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1116                    throws com.liferay.portal.kernel.exception.SystemException {
1117                    return getPersistence()
1118                                       .filterFindByG_C(groupId, categoryIds, start, end,
1119                            orderByComparator);
1120            }
1121    
1122            /**
1123            * Returns all the message boards threads where groupId = &#63; and categoryId = any &#63;.
1124            *
1125            * <p>
1126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1127            * </p>
1128            *
1129            * @param groupId the group ID
1130            * @param categoryIds the category IDs
1131            * @return the matching message boards threads
1132            * @throws SystemException if a system exception occurred
1133            */
1134            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
1135                    long groupId, long[] categoryIds)
1136                    throws com.liferay.portal.kernel.exception.SystemException {
1137                    return getPersistence().findByG_C(groupId, categoryIds);
1138            }
1139    
1140            /**
1141            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = any &#63;.
1142            *
1143            * <p>
1144            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1145            * </p>
1146            *
1147            * @param groupId the group ID
1148            * @param categoryIds the category IDs
1149            * @param start the lower bound of the range of message boards threads
1150            * @param end the upper bound of the range of message boards threads (not inclusive)
1151            * @return the range of matching message boards threads
1152            * @throws SystemException if a system exception occurred
1153            */
1154            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
1155                    long groupId, long[] categoryIds, int start, int end)
1156                    throws com.liferay.portal.kernel.exception.SystemException {
1157                    return getPersistence().findByG_C(groupId, categoryIds, start, end);
1158            }
1159    
1160            /**
1161            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = any &#63;.
1162            *
1163            * <p>
1164            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1165            * </p>
1166            *
1167            * @param groupId the group ID
1168            * @param categoryIds the category IDs
1169            * @param start the lower bound of the range of message boards threads
1170            * @param end the upper bound of the range of message boards threads (not inclusive)
1171            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1172            * @return the ordered range of matching message boards threads
1173            * @throws SystemException if a system exception occurred
1174            */
1175            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C(
1176                    long groupId, long[] categoryIds, int start, int end,
1177                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1178                    throws com.liferay.portal.kernel.exception.SystemException {
1179                    return getPersistence()
1180                                       .findByG_C(groupId, categoryIds, start, end,
1181                            orderByComparator);
1182            }
1183    
1184            /**
1185            * Removes all the message boards threads where groupId = &#63; and categoryId = &#63; from the database.
1186            *
1187            * @param groupId the group ID
1188            * @param categoryId the category ID
1189            * @throws SystemException if a system exception occurred
1190            */
1191            public static void removeByG_C(long groupId, long categoryId)
1192                    throws com.liferay.portal.kernel.exception.SystemException {
1193                    getPersistence().removeByG_C(groupId, categoryId);
1194            }
1195    
1196            /**
1197            * Returns the number of message boards threads where groupId = &#63; and categoryId = &#63;.
1198            *
1199            * @param groupId the group ID
1200            * @param categoryId the category ID
1201            * @return the number of matching message boards threads
1202            * @throws SystemException if a system exception occurred
1203            */
1204            public static int countByG_C(long groupId, long categoryId)
1205                    throws com.liferay.portal.kernel.exception.SystemException {
1206                    return getPersistence().countByG_C(groupId, categoryId);
1207            }
1208    
1209            /**
1210            * Returns the number of message boards threads where groupId = &#63; and categoryId = any &#63;.
1211            *
1212            * @param groupId the group ID
1213            * @param categoryIds the category IDs
1214            * @return the number of matching message boards threads
1215            * @throws SystemException if a system exception occurred
1216            */
1217            public static int countByG_C(long groupId, long[] categoryIds)
1218                    throws com.liferay.portal.kernel.exception.SystemException {
1219                    return getPersistence().countByG_C(groupId, categoryIds);
1220            }
1221    
1222            /**
1223            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63;.
1224            *
1225            * @param groupId the group ID
1226            * @param categoryId the category ID
1227            * @return the number of matching message boards threads that the user has permission to view
1228            * @throws SystemException if a system exception occurred
1229            */
1230            public static int filterCountByG_C(long groupId, long categoryId)
1231                    throws com.liferay.portal.kernel.exception.SystemException {
1232                    return getPersistence().filterCountByG_C(groupId, categoryId);
1233            }
1234    
1235            /**
1236            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63;.
1237            *
1238            * @param groupId the group ID
1239            * @param categoryIds the category IDs
1240            * @return the number of matching message boards threads that the user has permission to view
1241            * @throws SystemException if a system exception occurred
1242            */
1243            public static int filterCountByG_C(long groupId, long[] categoryIds)
1244                    throws com.liferay.portal.kernel.exception.SystemException {
1245                    return getPersistence().filterCountByG_C(groupId, categoryIds);
1246            }
1247    
1248            /**
1249            * Returns all the message boards threads where groupId = &#63; and categoryId &ne; &#63;.
1250            *
1251            * @param groupId the group ID
1252            * @param categoryId the category ID
1253            * @return the matching message boards threads
1254            * @throws SystemException if a system exception occurred
1255            */
1256            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC(
1257                    long groupId, long categoryId)
1258                    throws com.liferay.portal.kernel.exception.SystemException {
1259                    return getPersistence().findByG_NotC(groupId, categoryId);
1260            }
1261    
1262            /**
1263            * Returns a range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63;.
1264            *
1265            * <p>
1266            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1267            * </p>
1268            *
1269            * @param groupId the group ID
1270            * @param categoryId the category ID
1271            * @param start the lower bound of the range of message boards threads
1272            * @param end the upper bound of the range of message boards threads (not inclusive)
1273            * @return the range of matching message boards threads
1274            * @throws SystemException if a system exception occurred
1275            */
1276            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC(
1277                    long groupId, long categoryId, int start, int end)
1278                    throws com.liferay.portal.kernel.exception.SystemException {
1279                    return getPersistence().findByG_NotC(groupId, categoryId, start, end);
1280            }
1281    
1282            /**
1283            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63;.
1284            *
1285            * <p>
1286            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1287            * </p>
1288            *
1289            * @param groupId the group ID
1290            * @param categoryId the category ID
1291            * @param start the lower bound of the range of message boards threads
1292            * @param end the upper bound of the range of message boards threads (not inclusive)
1293            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1294            * @return the ordered range of matching message boards threads
1295            * @throws SystemException if a system exception occurred
1296            */
1297            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC(
1298                    long groupId, long categoryId, int start, int end,
1299                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1300                    throws com.liferay.portal.kernel.exception.SystemException {
1301                    return getPersistence()
1302                                       .findByG_NotC(groupId, categoryId, start, end,
1303                            orderByComparator);
1304            }
1305    
1306            /**
1307            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
1308            *
1309            * @param groupId the group ID
1310            * @param categoryId the category ID
1311            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1312            * @return the first matching message boards thread
1313            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1314            * @throws SystemException if a system exception occurred
1315            */
1316            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_First(
1317                    long groupId, long categoryId,
1318                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1319                    throws com.liferay.portal.kernel.exception.SystemException,
1320                            com.liferay.portlet.messageboards.NoSuchThreadException {
1321                    return getPersistence()
1322                                       .findByG_NotC_First(groupId, categoryId, orderByComparator);
1323            }
1324    
1325            /**
1326            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
1327            *
1328            * @param groupId the group ID
1329            * @param categoryId the category ID
1330            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1331            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1332            * @throws SystemException if a system exception occurred
1333            */
1334            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_First(
1335                    long groupId, long categoryId,
1336                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1337                    throws com.liferay.portal.kernel.exception.SystemException {
1338                    return getPersistence()
1339                                       .fetchByG_NotC_First(groupId, categoryId, orderByComparator);
1340            }
1341    
1342            /**
1343            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
1344            *
1345            * @param groupId the group ID
1346            * @param categoryId the category ID
1347            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1348            * @return the last matching message boards thread
1349            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1350            * @throws SystemException if a system exception occurred
1351            */
1352            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_Last(
1353                    long groupId, long categoryId,
1354                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1355                    throws com.liferay.portal.kernel.exception.SystemException,
1356                            com.liferay.portlet.messageboards.NoSuchThreadException {
1357                    return getPersistence()
1358                                       .findByG_NotC_Last(groupId, categoryId, orderByComparator);
1359            }
1360    
1361            /**
1362            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
1363            *
1364            * @param groupId the group ID
1365            * @param categoryId the category ID
1366            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1367            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1368            * @throws SystemException if a system exception occurred
1369            */
1370            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_Last(
1371                    long groupId, long categoryId,
1372                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1373                    throws com.liferay.portal.kernel.exception.SystemException {
1374                    return getPersistence()
1375                                       .fetchByG_NotC_Last(groupId, categoryId, orderByComparator);
1376            }
1377    
1378            /**
1379            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63;.
1380            *
1381            * @param threadId the primary key of the current message boards thread
1382            * @param groupId the group ID
1383            * @param categoryId the category ID
1384            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1385            * @return the previous, current, and next message boards thread
1386            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1387            * @throws SystemException if a system exception occurred
1388            */
1389            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_PrevAndNext(
1390                    long threadId, long groupId, long categoryId,
1391                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1392                    throws com.liferay.portal.kernel.exception.SystemException,
1393                            com.liferay.portlet.messageboards.NoSuchThreadException {
1394                    return getPersistence()
1395                                       .findByG_NotC_PrevAndNext(threadId, groupId, categoryId,
1396                            orderByComparator);
1397            }
1398    
1399            /**
1400            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63;.
1401            *
1402            * @param groupId the group ID
1403            * @param categoryId the category ID
1404            * @return the matching message boards threads that the user has permission to view
1405            * @throws SystemException if a system exception occurred
1406            */
1407            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC(
1408                    long groupId, long categoryId)
1409                    throws com.liferay.portal.kernel.exception.SystemException {
1410                    return getPersistence().filterFindByG_NotC(groupId, categoryId);
1411            }
1412    
1413            /**
1414            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63;.
1415            *
1416            * <p>
1417            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1418            * </p>
1419            *
1420            * @param groupId the group ID
1421            * @param categoryId the category ID
1422            * @param start the lower bound of the range of message boards threads
1423            * @param end the upper bound of the range of message boards threads (not inclusive)
1424            * @return the range of matching message boards threads that the user has permission to view
1425            * @throws SystemException if a system exception occurred
1426            */
1427            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC(
1428                    long groupId, long categoryId, int start, int end)
1429                    throws com.liferay.portal.kernel.exception.SystemException {
1430                    return getPersistence()
1431                                       .filterFindByG_NotC(groupId, categoryId, start, end);
1432            }
1433    
1434            /**
1435            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId &ne; &#63;.
1436            *
1437            * <p>
1438            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1439            * </p>
1440            *
1441            * @param groupId the group ID
1442            * @param categoryId the category ID
1443            * @param start the lower bound of the range of message boards threads
1444            * @param end the upper bound of the range of message boards threads (not inclusive)
1445            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1446            * @return the ordered range of matching message boards threads that the user has permission to view
1447            * @throws SystemException if a system exception occurred
1448            */
1449            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC(
1450                    long groupId, long categoryId, int start, int end,
1451                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1452                    throws com.liferay.portal.kernel.exception.SystemException {
1453                    return getPersistence()
1454                                       .filterFindByG_NotC(groupId, categoryId, start, end,
1455                            orderByComparator);
1456            }
1457    
1458            /**
1459            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63;.
1460            *
1461            * @param threadId the primary key of the current message boards thread
1462            * @param groupId the group ID
1463            * @param categoryId the category ID
1464            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1465            * @return the previous, current, and next message boards thread
1466            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1467            * @throws SystemException if a system exception occurred
1468            */
1469            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_NotC_PrevAndNext(
1470                    long threadId, long groupId, long categoryId,
1471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1472                    throws com.liferay.portal.kernel.exception.SystemException,
1473                            com.liferay.portlet.messageboards.NoSuchThreadException {
1474                    return getPersistence()
1475                                       .filterFindByG_NotC_PrevAndNext(threadId, groupId,
1476                            categoryId, orderByComparator);
1477            }
1478    
1479            /**
1480            * Removes all the message boards threads where groupId = &#63; and categoryId &ne; &#63; from the database.
1481            *
1482            * @param groupId the group ID
1483            * @param categoryId the category ID
1484            * @throws SystemException if a system exception occurred
1485            */
1486            public static void removeByG_NotC(long groupId, long categoryId)
1487                    throws com.liferay.portal.kernel.exception.SystemException {
1488                    getPersistence().removeByG_NotC(groupId, categoryId);
1489            }
1490    
1491            /**
1492            * Returns the number of message boards threads where groupId = &#63; and categoryId &ne; &#63;.
1493            *
1494            * @param groupId the group ID
1495            * @param categoryId the category ID
1496            * @return the number of matching message boards threads
1497            * @throws SystemException if a system exception occurred
1498            */
1499            public static int countByG_NotC(long groupId, long categoryId)
1500                    throws com.liferay.portal.kernel.exception.SystemException {
1501                    return getPersistence().countByG_NotC(groupId, categoryId);
1502            }
1503    
1504            /**
1505            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63;.
1506            *
1507            * @param groupId the group ID
1508            * @param categoryId the category ID
1509            * @return the number of matching message boards threads that the user has permission to view
1510            * @throws SystemException if a system exception occurred
1511            */
1512            public static int filterCountByG_NotC(long groupId, long categoryId)
1513                    throws com.liferay.portal.kernel.exception.SystemException {
1514                    return getPersistence().filterCountByG_NotC(groupId, categoryId);
1515            }
1516    
1517            /**
1518            * Returns all the message boards threads where groupId = &#63; and status = &#63;.
1519            *
1520            * @param groupId the group ID
1521            * @param status the status
1522            * @return the matching message boards threads
1523            * @throws SystemException if a system exception occurred
1524            */
1525            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S(
1526                    long groupId, int status)
1527                    throws com.liferay.portal.kernel.exception.SystemException {
1528                    return getPersistence().findByG_S(groupId, status);
1529            }
1530    
1531            /**
1532            * Returns a range of all the message boards threads where groupId = &#63; and status = &#63;.
1533            *
1534            * <p>
1535            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1536            * </p>
1537            *
1538            * @param groupId the group ID
1539            * @param status the status
1540            * @param start the lower bound of the range of message boards threads
1541            * @param end the upper bound of the range of message boards threads (not inclusive)
1542            * @return the range of matching message boards threads
1543            * @throws SystemException if a system exception occurred
1544            */
1545            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S(
1546                    long groupId, int status, int start, int end)
1547                    throws com.liferay.portal.kernel.exception.SystemException {
1548                    return getPersistence().findByG_S(groupId, status, start, end);
1549            }
1550    
1551            /**
1552            * Returns an ordered range of all the message boards threads where groupId = &#63; and status = &#63;.
1553            *
1554            * <p>
1555            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1556            * </p>
1557            *
1558            * @param groupId the group ID
1559            * @param status the status
1560            * @param start the lower bound of the range of message boards threads
1561            * @param end the upper bound of the range of message boards threads (not inclusive)
1562            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1563            * @return the ordered range of matching message boards threads
1564            * @throws SystemException if a system exception occurred
1565            */
1566            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_S(
1567                    long groupId, int status, int start, int end,
1568                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1569                    throws com.liferay.portal.kernel.exception.SystemException {
1570                    return getPersistence()
1571                                       .findByG_S(groupId, status, start, end, orderByComparator);
1572            }
1573    
1574            /**
1575            * Returns the first message boards thread in the ordered set where groupId = &#63; and status = &#63;.
1576            *
1577            * @param groupId the group ID
1578            * @param status the status
1579            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1580            * @return the first matching message boards thread
1581            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1582            * @throws SystemException if a system exception occurred
1583            */
1584            public static com.liferay.portlet.messageboards.model.MBThread findByG_S_First(
1585                    long groupId, int status,
1586                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1587                    throws com.liferay.portal.kernel.exception.SystemException,
1588                            com.liferay.portlet.messageboards.NoSuchThreadException {
1589                    return getPersistence()
1590                                       .findByG_S_First(groupId, status, orderByComparator);
1591            }
1592    
1593            /**
1594            * Returns the first message boards thread in the ordered set where groupId = &#63; and status = &#63;.
1595            *
1596            * @param groupId the group ID
1597            * @param status the status
1598            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1599            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1600            * @throws SystemException if a system exception occurred
1601            */
1602            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_S_First(
1603                    long groupId, int status,
1604                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1605                    throws com.liferay.portal.kernel.exception.SystemException {
1606                    return getPersistence()
1607                                       .fetchByG_S_First(groupId, status, orderByComparator);
1608            }
1609    
1610            /**
1611            * Returns the last message boards thread in the ordered set where groupId = &#63; and status = &#63;.
1612            *
1613            * @param groupId the group ID
1614            * @param status the status
1615            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1616            * @return the last matching message boards thread
1617            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1618            * @throws SystemException if a system exception occurred
1619            */
1620            public static com.liferay.portlet.messageboards.model.MBThread findByG_S_Last(
1621                    long groupId, int status,
1622                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1623                    throws com.liferay.portal.kernel.exception.SystemException,
1624                            com.liferay.portlet.messageboards.NoSuchThreadException {
1625                    return getPersistence()
1626                                       .findByG_S_Last(groupId, status, orderByComparator);
1627            }
1628    
1629            /**
1630            * Returns the last message boards thread in the ordered set where groupId = &#63; and status = &#63;.
1631            *
1632            * @param groupId the group ID
1633            * @param status the status
1634            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1635            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1636            * @throws SystemException if a system exception occurred
1637            */
1638            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_S_Last(
1639                    long groupId, int status,
1640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1641                    throws com.liferay.portal.kernel.exception.SystemException {
1642                    return getPersistence()
1643                                       .fetchByG_S_Last(groupId, status, orderByComparator);
1644            }
1645    
1646            /**
1647            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and status = &#63;.
1648            *
1649            * @param threadId the primary key of the current message boards thread
1650            * @param groupId the group ID
1651            * @param status the status
1652            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1653            * @return the previous, current, and next message boards thread
1654            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1655            * @throws SystemException if a system exception occurred
1656            */
1657            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_S_PrevAndNext(
1658                    long threadId, long groupId, int status,
1659                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1660                    throws com.liferay.portal.kernel.exception.SystemException,
1661                            com.liferay.portlet.messageboards.NoSuchThreadException {
1662                    return getPersistence()
1663                                       .findByG_S_PrevAndNext(threadId, groupId, status,
1664                            orderByComparator);
1665            }
1666    
1667            /**
1668            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and status = &#63;.
1669            *
1670            * @param groupId the group ID
1671            * @param status the status
1672            * @return the matching message boards threads that the user has permission to view
1673            * @throws SystemException if a system exception occurred
1674            */
1675            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S(
1676                    long groupId, int status)
1677                    throws com.liferay.portal.kernel.exception.SystemException {
1678                    return getPersistence().filterFindByG_S(groupId, status);
1679            }
1680    
1681            /**
1682            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and status = &#63;.
1683            *
1684            * <p>
1685            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1686            * </p>
1687            *
1688            * @param groupId the group ID
1689            * @param status the status
1690            * @param start the lower bound of the range of message boards threads
1691            * @param end the upper bound of the range of message boards threads (not inclusive)
1692            * @return the range of matching message boards threads that the user has permission to view
1693            * @throws SystemException if a system exception occurred
1694            */
1695            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S(
1696                    long groupId, int status, int start, int end)
1697                    throws com.liferay.portal.kernel.exception.SystemException {
1698                    return getPersistence().filterFindByG_S(groupId, status, start, end);
1699            }
1700    
1701            /**
1702            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and status = &#63;.
1703            *
1704            * <p>
1705            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1706            * </p>
1707            *
1708            * @param groupId the group ID
1709            * @param status the status
1710            * @param start the lower bound of the range of message boards threads
1711            * @param end the upper bound of the range of message boards threads (not inclusive)
1712            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1713            * @return the ordered range of matching message boards threads that the user has permission to view
1714            * @throws SystemException if a system exception occurred
1715            */
1716            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_S(
1717                    long groupId, int status, int start, int end,
1718                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1719                    throws com.liferay.portal.kernel.exception.SystemException {
1720                    return getPersistence()
1721                                       .filterFindByG_S(groupId, status, start, end,
1722                            orderByComparator);
1723            }
1724    
1725            /**
1726            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and status = &#63;.
1727            *
1728            * @param threadId the primary key of the current message boards thread
1729            * @param groupId the group ID
1730            * @param status the status
1731            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1732            * @return the previous, current, and next message boards thread
1733            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1734            * @throws SystemException if a system exception occurred
1735            */
1736            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_S_PrevAndNext(
1737                    long threadId, long groupId, int status,
1738                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1739                    throws com.liferay.portal.kernel.exception.SystemException,
1740                            com.liferay.portlet.messageboards.NoSuchThreadException {
1741                    return getPersistence()
1742                                       .filterFindByG_S_PrevAndNext(threadId, groupId, status,
1743                            orderByComparator);
1744            }
1745    
1746            /**
1747            * Removes all the message boards threads where groupId = &#63; and status = &#63; from the database.
1748            *
1749            * @param groupId the group ID
1750            * @param status the status
1751            * @throws SystemException if a system exception occurred
1752            */
1753            public static void removeByG_S(long groupId, int status)
1754                    throws com.liferay.portal.kernel.exception.SystemException {
1755                    getPersistence().removeByG_S(groupId, status);
1756            }
1757    
1758            /**
1759            * Returns the number of message boards threads where groupId = &#63; and status = &#63;.
1760            *
1761            * @param groupId the group ID
1762            * @param status the status
1763            * @return the number of matching message boards threads
1764            * @throws SystemException if a system exception occurred
1765            */
1766            public static int countByG_S(long groupId, int status)
1767                    throws com.liferay.portal.kernel.exception.SystemException {
1768                    return getPersistence().countByG_S(groupId, status);
1769            }
1770    
1771            /**
1772            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and status = &#63;.
1773            *
1774            * @param groupId the group ID
1775            * @param status the status
1776            * @return the number of matching message boards threads that the user has permission to view
1777            * @throws SystemException if a system exception occurred
1778            */
1779            public static int filterCountByG_S(long groupId, int status)
1780                    throws com.liferay.portal.kernel.exception.SystemException {
1781                    return getPersistence().filterCountByG_S(groupId, status);
1782            }
1783    
1784            /**
1785            * Returns all the message boards threads where categoryId = &#63; and priority = &#63;.
1786            *
1787            * @param categoryId the category ID
1788            * @param priority the priority
1789            * @return the matching message boards threads
1790            * @throws SystemException if a system exception occurred
1791            */
1792            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P(
1793                    long categoryId, double priority)
1794                    throws com.liferay.portal.kernel.exception.SystemException {
1795                    return getPersistence().findByC_P(categoryId, priority);
1796            }
1797    
1798            /**
1799            * Returns a range of all the message boards threads where categoryId = &#63; and priority = &#63;.
1800            *
1801            * <p>
1802            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1803            * </p>
1804            *
1805            * @param categoryId the category ID
1806            * @param priority the priority
1807            * @param start the lower bound of the range of message boards threads
1808            * @param end the upper bound of the range of message boards threads (not inclusive)
1809            * @return the range of matching message boards threads
1810            * @throws SystemException if a system exception occurred
1811            */
1812            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P(
1813                    long categoryId, double priority, int start, int end)
1814                    throws com.liferay.portal.kernel.exception.SystemException {
1815                    return getPersistence().findByC_P(categoryId, priority, start, end);
1816            }
1817    
1818            /**
1819            * Returns an ordered range of all the message boards threads where categoryId = &#63; and priority = &#63;.
1820            *
1821            * <p>
1822            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1823            * </p>
1824            *
1825            * @param categoryId the category ID
1826            * @param priority the priority
1827            * @param start the lower bound of the range of message boards threads
1828            * @param end the upper bound of the range of message boards threads (not inclusive)
1829            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1830            * @return the ordered range of matching message boards threads
1831            * @throws SystemException if a system exception occurred
1832            */
1833            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByC_P(
1834                    long categoryId, double priority, int start, int end,
1835                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1836                    throws com.liferay.portal.kernel.exception.SystemException {
1837                    return getPersistence()
1838                                       .findByC_P(categoryId, priority, start, end,
1839                            orderByComparator);
1840            }
1841    
1842            /**
1843            * Returns the first message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
1844            *
1845            * @param categoryId the category ID
1846            * @param priority the priority
1847            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1848            * @return the first matching message boards thread
1849            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1850            * @throws SystemException if a system exception occurred
1851            */
1852            public static com.liferay.portlet.messageboards.model.MBThread findByC_P_First(
1853                    long categoryId, double priority,
1854                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1855                    throws com.liferay.portal.kernel.exception.SystemException,
1856                            com.liferay.portlet.messageboards.NoSuchThreadException {
1857                    return getPersistence()
1858                                       .findByC_P_First(categoryId, priority, orderByComparator);
1859            }
1860    
1861            /**
1862            * Returns the first message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
1863            *
1864            * @param categoryId the category ID
1865            * @param priority the priority
1866            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1867            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1868            * @throws SystemException if a system exception occurred
1869            */
1870            public static com.liferay.portlet.messageboards.model.MBThread fetchByC_P_First(
1871                    long categoryId, double priority,
1872                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1873                    throws com.liferay.portal.kernel.exception.SystemException {
1874                    return getPersistence()
1875                                       .fetchByC_P_First(categoryId, priority, orderByComparator);
1876            }
1877    
1878            /**
1879            * Returns the last message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
1880            *
1881            * @param categoryId the category ID
1882            * @param priority the priority
1883            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1884            * @return the last matching message boards thread
1885            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
1886            * @throws SystemException if a system exception occurred
1887            */
1888            public static com.liferay.portlet.messageboards.model.MBThread findByC_P_Last(
1889                    long categoryId, double priority,
1890                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1891                    throws com.liferay.portal.kernel.exception.SystemException,
1892                            com.liferay.portlet.messageboards.NoSuchThreadException {
1893                    return getPersistence()
1894                                       .findByC_P_Last(categoryId, priority, orderByComparator);
1895            }
1896    
1897            /**
1898            * Returns the last message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
1899            *
1900            * @param categoryId the category ID
1901            * @param priority the priority
1902            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1903            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
1904            * @throws SystemException if a system exception occurred
1905            */
1906            public static com.liferay.portlet.messageboards.model.MBThread fetchByC_P_Last(
1907                    long categoryId, double priority,
1908                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1909                    throws com.liferay.portal.kernel.exception.SystemException {
1910                    return getPersistence()
1911                                       .fetchByC_P_Last(categoryId, priority, orderByComparator);
1912            }
1913    
1914            /**
1915            * Returns the message boards threads before and after the current message boards thread in the ordered set where categoryId = &#63; and priority = &#63;.
1916            *
1917            * @param threadId the primary key of the current message boards thread
1918            * @param categoryId the category ID
1919            * @param priority the priority
1920            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1921            * @return the previous, current, and next message boards thread
1922            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
1923            * @throws SystemException if a system exception occurred
1924            */
1925            public static com.liferay.portlet.messageboards.model.MBThread[] findByC_P_PrevAndNext(
1926                    long threadId, long categoryId, double priority,
1927                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1928                    throws com.liferay.portal.kernel.exception.SystemException,
1929                            com.liferay.portlet.messageboards.NoSuchThreadException {
1930                    return getPersistence()
1931                                       .findByC_P_PrevAndNext(threadId, categoryId, priority,
1932                            orderByComparator);
1933            }
1934    
1935            /**
1936            * Removes all the message boards threads where categoryId = &#63; and priority = &#63; from the database.
1937            *
1938            * @param categoryId the category ID
1939            * @param priority the priority
1940            * @throws SystemException if a system exception occurred
1941            */
1942            public static void removeByC_P(long categoryId, double priority)
1943                    throws com.liferay.portal.kernel.exception.SystemException {
1944                    getPersistence().removeByC_P(categoryId, priority);
1945            }
1946    
1947            /**
1948            * Returns the number of message boards threads where categoryId = &#63; and priority = &#63;.
1949            *
1950            * @param categoryId the category ID
1951            * @param priority the priority
1952            * @return the number of matching message boards threads
1953            * @throws SystemException if a system exception occurred
1954            */
1955            public static int countByC_P(long categoryId, double priority)
1956                    throws com.liferay.portal.kernel.exception.SystemException {
1957                    return getPersistence().countByC_P(categoryId, priority);
1958            }
1959    
1960            /**
1961            * Returns all the message boards threads where lastPostDate = &#63; and priority = &#63;.
1962            *
1963            * @param lastPostDate the last post date
1964            * @param priority the priority
1965            * @return the matching message boards threads
1966            * @throws SystemException if a system exception occurred
1967            */
1968            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P(
1969                    java.util.Date lastPostDate, double priority)
1970                    throws com.liferay.portal.kernel.exception.SystemException {
1971                    return getPersistence().findByL_P(lastPostDate, priority);
1972            }
1973    
1974            /**
1975            * Returns a range of all the message boards threads where lastPostDate = &#63; and priority = &#63;.
1976            *
1977            * <p>
1978            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1979            * </p>
1980            *
1981            * @param lastPostDate the last post date
1982            * @param priority the priority
1983            * @param start the lower bound of the range of message boards threads
1984            * @param end the upper bound of the range of message boards threads (not inclusive)
1985            * @return the range of matching message boards threads
1986            * @throws SystemException if a system exception occurred
1987            */
1988            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P(
1989                    java.util.Date lastPostDate, double priority, int start, int end)
1990                    throws com.liferay.portal.kernel.exception.SystemException {
1991                    return getPersistence().findByL_P(lastPostDate, priority, start, end);
1992            }
1993    
1994            /**
1995            * Returns an ordered range of all the message boards threads where lastPostDate = &#63; and priority = &#63;.
1996            *
1997            * <p>
1998            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1999            * </p>
2000            *
2001            * @param lastPostDate the last post date
2002            * @param priority the priority
2003            * @param start the lower bound of the range of message boards threads
2004            * @param end the upper bound of the range of message boards threads (not inclusive)
2005            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2006            * @return the ordered range of matching message boards threads
2007            * @throws SystemException if a system exception occurred
2008            */
2009            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByL_P(
2010                    java.util.Date lastPostDate, double priority, int start, int end,
2011                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2012                    throws com.liferay.portal.kernel.exception.SystemException {
2013                    return getPersistence()
2014                                       .findByL_P(lastPostDate, priority, start, end,
2015                            orderByComparator);
2016            }
2017    
2018            /**
2019            * Returns the first message boards thread in the ordered set where lastPostDate = &#63; and priority = &#63;.
2020            *
2021            * @param lastPostDate the last post date
2022            * @param priority the priority
2023            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2024            * @return the first matching message boards thread
2025            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
2026            * @throws SystemException if a system exception occurred
2027            */
2028            public static com.liferay.portlet.messageboards.model.MBThread findByL_P_First(
2029                    java.util.Date lastPostDate, double priority,
2030                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2031                    throws com.liferay.portal.kernel.exception.SystemException,
2032                            com.liferay.portlet.messageboards.NoSuchThreadException {
2033                    return getPersistence()
2034                                       .findByL_P_First(lastPostDate, priority, orderByComparator);
2035            }
2036    
2037            /**
2038            * Returns the first message boards thread in the ordered set where lastPostDate = &#63; and priority = &#63;.
2039            *
2040            * @param lastPostDate the last post date
2041            * @param priority the priority
2042            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2043            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
2044            * @throws SystemException if a system exception occurred
2045            */
2046            public static com.liferay.portlet.messageboards.model.MBThread fetchByL_P_First(
2047                    java.util.Date lastPostDate, double priority,
2048                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2049                    throws com.liferay.portal.kernel.exception.SystemException {
2050                    return getPersistence()
2051                                       .fetchByL_P_First(lastPostDate, priority, orderByComparator);
2052            }
2053    
2054            /**
2055            * Returns the last message boards thread in the ordered set where lastPostDate = &#63; and priority = &#63;.
2056            *
2057            * @param lastPostDate the last post date
2058            * @param priority the priority
2059            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2060            * @return the last matching message boards thread
2061            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
2062            * @throws SystemException if a system exception occurred
2063            */
2064            public static com.liferay.portlet.messageboards.model.MBThread findByL_P_Last(
2065                    java.util.Date lastPostDate, double priority,
2066                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2067                    throws com.liferay.portal.kernel.exception.SystemException,
2068                            com.liferay.portlet.messageboards.NoSuchThreadException {
2069                    return getPersistence()
2070                                       .findByL_P_Last(lastPostDate, priority, orderByComparator);
2071            }
2072    
2073            /**
2074            * Returns the last message boards thread in the ordered set where lastPostDate = &#63; and priority = &#63;.
2075            *
2076            * @param lastPostDate the last post date
2077            * @param priority the priority
2078            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2079            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
2080            * @throws SystemException if a system exception occurred
2081            */
2082            public static com.liferay.portlet.messageboards.model.MBThread fetchByL_P_Last(
2083                    java.util.Date lastPostDate, double priority,
2084                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2085                    throws com.liferay.portal.kernel.exception.SystemException {
2086                    return getPersistence()
2087                                       .fetchByL_P_Last(lastPostDate, priority, orderByComparator);
2088            }
2089    
2090            /**
2091            * Returns the message boards threads before and after the current message boards thread in the ordered set where lastPostDate = &#63; and priority = &#63;.
2092            *
2093            * @param threadId the primary key of the current message boards thread
2094            * @param lastPostDate the last post date
2095            * @param priority the priority
2096            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2097            * @return the previous, current, and next message boards thread
2098            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
2099            * @throws SystemException if a system exception occurred
2100            */
2101            public static com.liferay.portlet.messageboards.model.MBThread[] findByL_P_PrevAndNext(
2102                    long threadId, java.util.Date lastPostDate, double priority,
2103                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2104                    throws com.liferay.portal.kernel.exception.SystemException,
2105                            com.liferay.portlet.messageboards.NoSuchThreadException {
2106                    return getPersistence()
2107                                       .findByL_P_PrevAndNext(threadId, lastPostDate, priority,
2108                            orderByComparator);
2109            }
2110    
2111            /**
2112            * Removes all the message boards threads where lastPostDate = &#63; and priority = &#63; from the database.
2113            *
2114            * @param lastPostDate the last post date
2115            * @param priority the priority
2116            * @throws SystemException if a system exception occurred
2117            */
2118            public static void removeByL_P(java.util.Date lastPostDate, double priority)
2119                    throws com.liferay.portal.kernel.exception.SystemException {
2120                    getPersistence().removeByL_P(lastPostDate, priority);
2121            }
2122    
2123            /**
2124            * Returns the number of message boards threads where lastPostDate = &#63; and priority = &#63;.
2125            *
2126            * @param lastPostDate the last post date
2127            * @param priority the priority
2128            * @return the number of matching message boards threads
2129            * @throws SystemException if a system exception occurred
2130            */
2131            public static int countByL_P(java.util.Date lastPostDate, double priority)
2132                    throws com.liferay.portal.kernel.exception.SystemException {
2133                    return getPersistence().countByL_P(lastPostDate, priority);
2134            }
2135    
2136            /**
2137            * Returns all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2138            *
2139            * @param groupId the group ID
2140            * @param categoryId the category ID
2141            * @param lastPostDate the last post date
2142            * @return the matching message boards threads
2143            * @throws SystemException if a system exception occurred
2144            */
2145            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L(
2146                    long groupId, long categoryId, java.util.Date lastPostDate)
2147                    throws com.liferay.portal.kernel.exception.SystemException {
2148                    return getPersistence().findByG_C_L(groupId, categoryId, lastPostDate);
2149            }
2150    
2151            /**
2152            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2153            *
2154            * <p>
2155            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2156            * </p>
2157            *
2158            * @param groupId the group ID
2159            * @param categoryId the category ID
2160            * @param lastPostDate the last post date
2161            * @param start the lower bound of the range of message boards threads
2162            * @param end the upper bound of the range of message boards threads (not inclusive)
2163            * @return the range of matching message boards threads
2164            * @throws SystemException if a system exception occurred
2165            */
2166            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L(
2167                    long groupId, long categoryId, java.util.Date lastPostDate, int start,
2168                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2169                    return getPersistence()
2170                                       .findByG_C_L(groupId, categoryId, lastPostDate, start, end);
2171            }
2172    
2173            /**
2174            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2175            *
2176            * <p>
2177            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2178            * </p>
2179            *
2180            * @param groupId the group ID
2181            * @param categoryId the category ID
2182            * @param lastPostDate the last post date
2183            * @param start the lower bound of the range of message boards threads
2184            * @param end the upper bound of the range of message boards threads (not inclusive)
2185            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2186            * @return the ordered range of matching message boards threads
2187            * @throws SystemException if a system exception occurred
2188            */
2189            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_L(
2190                    long groupId, long categoryId, java.util.Date lastPostDate, int start,
2191                    int end,
2192                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2193                    throws com.liferay.portal.kernel.exception.SystemException {
2194                    return getPersistence()
2195                                       .findByG_C_L(groupId, categoryId, lastPostDate, start, end,
2196                            orderByComparator);
2197            }
2198    
2199            /**
2200            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2201            *
2202            * @param groupId the group ID
2203            * @param categoryId the category ID
2204            * @param lastPostDate the last post date
2205            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2206            * @return the first matching message boards thread
2207            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
2208            * @throws SystemException if a system exception occurred
2209            */
2210            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_First(
2211                    long groupId, long categoryId, java.util.Date lastPostDate,
2212                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2213                    throws com.liferay.portal.kernel.exception.SystemException,
2214                            com.liferay.portlet.messageboards.NoSuchThreadException {
2215                    return getPersistence()
2216                                       .findByG_C_L_First(groupId, categoryId, lastPostDate,
2217                            orderByComparator);
2218            }
2219    
2220            /**
2221            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2222            *
2223            * @param groupId the group ID
2224            * @param categoryId the category ID
2225            * @param lastPostDate the last post date
2226            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2227            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
2228            * @throws SystemException if a system exception occurred
2229            */
2230            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_L_First(
2231                    long groupId, long categoryId, java.util.Date lastPostDate,
2232                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2233                    throws com.liferay.portal.kernel.exception.SystemException {
2234                    return getPersistence()
2235                                       .fetchByG_C_L_First(groupId, categoryId, lastPostDate,
2236                            orderByComparator);
2237            }
2238    
2239            /**
2240            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2241            *
2242            * @param groupId the group ID
2243            * @param categoryId the category ID
2244            * @param lastPostDate the last post date
2245            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2246            * @return the last matching message boards thread
2247            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
2248            * @throws SystemException if a system exception occurred
2249            */
2250            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_L_Last(
2251                    long groupId, long categoryId, java.util.Date lastPostDate,
2252                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2253                    throws com.liferay.portal.kernel.exception.SystemException,
2254                            com.liferay.portlet.messageboards.NoSuchThreadException {
2255                    return getPersistence()
2256                                       .findByG_C_L_Last(groupId, categoryId, lastPostDate,
2257                            orderByComparator);
2258            }
2259    
2260            /**
2261            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2262            *
2263            * @param groupId the group ID
2264            * @param categoryId the category ID
2265            * @param lastPostDate the last post date
2266            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2267            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
2268            * @throws SystemException if a system exception occurred
2269            */
2270            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_L_Last(
2271                    long groupId, long categoryId, java.util.Date lastPostDate,
2272                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2273                    throws com.liferay.portal.kernel.exception.SystemException {
2274                    return getPersistence()
2275                                       .fetchByG_C_L_Last(groupId, categoryId, lastPostDate,
2276                            orderByComparator);
2277            }
2278    
2279            /**
2280            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2281            *
2282            * @param threadId the primary key of the current message boards thread
2283            * @param groupId the group ID
2284            * @param categoryId the category ID
2285            * @param lastPostDate the last post date
2286            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2287            * @return the previous, current, and next message boards thread
2288            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
2289            * @throws SystemException if a system exception occurred
2290            */
2291            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_L_PrevAndNext(
2292                    long threadId, long groupId, long categoryId,
2293                    java.util.Date lastPostDate,
2294                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2295                    throws com.liferay.portal.kernel.exception.SystemException,
2296                            com.liferay.portlet.messageboards.NoSuchThreadException {
2297                    return getPersistence()
2298                                       .findByG_C_L_PrevAndNext(threadId, groupId, categoryId,
2299                            lastPostDate, orderByComparator);
2300            }
2301    
2302            /**
2303            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2304            *
2305            * @param groupId the group ID
2306            * @param categoryId the category ID
2307            * @param lastPostDate the last post date
2308            * @return the matching message boards threads that the user has permission to view
2309            * @throws SystemException if a system exception occurred
2310            */
2311            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L(
2312                    long groupId, long categoryId, java.util.Date lastPostDate)
2313                    throws com.liferay.portal.kernel.exception.SystemException {
2314                    return getPersistence()
2315                                       .filterFindByG_C_L(groupId, categoryId, lastPostDate);
2316            }
2317    
2318            /**
2319            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2320            *
2321            * <p>
2322            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2323            * </p>
2324            *
2325            * @param groupId the group ID
2326            * @param categoryId the category ID
2327            * @param lastPostDate the last post date
2328            * @param start the lower bound of the range of message boards threads
2329            * @param end the upper bound of the range of message boards threads (not inclusive)
2330            * @return the range of matching message boards threads that the user has permission to view
2331            * @throws SystemException if a system exception occurred
2332            */
2333            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L(
2334                    long groupId, long categoryId, java.util.Date lastPostDate, int start,
2335                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2336                    return getPersistence()
2337                                       .filterFindByG_C_L(groupId, categoryId, lastPostDate, start,
2338                            end);
2339            }
2340    
2341            /**
2342            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2343            *
2344            * <p>
2345            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2346            * </p>
2347            *
2348            * @param groupId the group ID
2349            * @param categoryId the category ID
2350            * @param lastPostDate the last post date
2351            * @param start the lower bound of the range of message boards threads
2352            * @param end the upper bound of the range of message boards threads (not inclusive)
2353            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2354            * @return the ordered range of matching message boards threads that the user has permission to view
2355            * @throws SystemException if a system exception occurred
2356            */
2357            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_L(
2358                    long groupId, long categoryId, java.util.Date lastPostDate, int start,
2359                    int end,
2360                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2361                    throws com.liferay.portal.kernel.exception.SystemException {
2362                    return getPersistence()
2363                                       .filterFindByG_C_L(groupId, categoryId, lastPostDate, start,
2364                            end, orderByComparator);
2365            }
2366    
2367            /**
2368            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2369            *
2370            * @param threadId the primary key of the current message boards thread
2371            * @param groupId the group ID
2372            * @param categoryId the category ID
2373            * @param lastPostDate the last post date
2374            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2375            * @return the previous, current, and next message boards thread
2376            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
2377            * @throws SystemException if a system exception occurred
2378            */
2379            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_L_PrevAndNext(
2380                    long threadId, long groupId, long categoryId,
2381                    java.util.Date lastPostDate,
2382                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2383                    throws com.liferay.portal.kernel.exception.SystemException,
2384                            com.liferay.portlet.messageboards.NoSuchThreadException {
2385                    return getPersistence()
2386                                       .filterFindByG_C_L_PrevAndNext(threadId, groupId,
2387                            categoryId, lastPostDate, orderByComparator);
2388            }
2389    
2390            /**
2391            * Removes all the message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63; from the database.
2392            *
2393            * @param groupId the group ID
2394            * @param categoryId the category ID
2395            * @param lastPostDate the last post date
2396            * @throws SystemException if a system exception occurred
2397            */
2398            public static void removeByG_C_L(long groupId, long categoryId,
2399                    java.util.Date lastPostDate)
2400                    throws com.liferay.portal.kernel.exception.SystemException {
2401                    getPersistence().removeByG_C_L(groupId, categoryId, lastPostDate);
2402            }
2403    
2404            /**
2405            * Returns the number of message boards threads where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2406            *
2407            * @param groupId the group ID
2408            * @param categoryId the category ID
2409            * @param lastPostDate the last post date
2410            * @return the number of matching message boards threads
2411            * @throws SystemException if a system exception occurred
2412            */
2413            public static int countByG_C_L(long groupId, long categoryId,
2414                    java.util.Date lastPostDate)
2415                    throws com.liferay.portal.kernel.exception.SystemException {
2416                    return getPersistence().countByG_C_L(groupId, categoryId, lastPostDate);
2417            }
2418    
2419            /**
2420            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and lastPostDate = &#63;.
2421            *
2422            * @param groupId the group ID
2423            * @param categoryId the category ID
2424            * @param lastPostDate the last post date
2425            * @return the number of matching message boards threads that the user has permission to view
2426            * @throws SystemException if a system exception occurred
2427            */
2428            public static int filterCountByG_C_L(long groupId, long categoryId,
2429                    java.util.Date lastPostDate)
2430                    throws com.liferay.portal.kernel.exception.SystemException {
2431                    return getPersistence()
2432                                       .filterCountByG_C_L(groupId, categoryId, lastPostDate);
2433            }
2434    
2435            /**
2436            * Returns all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
2437            *
2438            * @param groupId the group ID
2439            * @param categoryId the category ID
2440            * @param status the status
2441            * @return the matching message boards threads
2442            * @throws SystemException if a system exception occurred
2443            */
2444            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
2445                    long groupId, long categoryId, int status)
2446                    throws com.liferay.portal.kernel.exception.SystemException {
2447                    return getPersistence().findByG_C_S(groupId, categoryId, status);
2448            }
2449    
2450            /**
2451            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
2452            *
2453            * <p>
2454            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2455            * </p>
2456            *
2457            * @param groupId the group ID
2458            * @param categoryId the category ID
2459            * @param status the status
2460            * @param start the lower bound of the range of message boards threads
2461            * @param end the upper bound of the range of message boards threads (not inclusive)
2462            * @return the range of matching message boards threads
2463            * @throws SystemException if a system exception occurred
2464            */
2465            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
2466                    long groupId, long categoryId, int status, int start, int end)
2467                    throws com.liferay.portal.kernel.exception.SystemException {
2468                    return getPersistence()
2469                                       .findByG_C_S(groupId, categoryId, status, start, end);
2470            }
2471    
2472            /**
2473            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
2474            *
2475            * <p>
2476            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2477            * </p>
2478            *
2479            * @param groupId the group ID
2480            * @param categoryId the category ID
2481            * @param status the status
2482            * @param start the lower bound of the range of message boards threads
2483            * @param end the upper bound of the range of message boards threads (not inclusive)
2484            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2485            * @return the ordered range of matching message boards threads
2486            * @throws SystemException if a system exception occurred
2487            */
2488            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
2489                    long groupId, long categoryId, int status, int start, int end,
2490                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2491                    throws com.liferay.portal.kernel.exception.SystemException {
2492                    return getPersistence()
2493                                       .findByG_C_S(groupId, categoryId, status, start, end,
2494                            orderByComparator);
2495            }
2496    
2497            /**
2498            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
2499            *
2500            * @param groupId the group ID
2501            * @param categoryId the category ID
2502            * @param status the status
2503            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2504            * @return the first matching message boards thread
2505            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
2506            * @throws SystemException if a system exception occurred
2507            */
2508            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_First(
2509                    long groupId, long categoryId, int status,
2510                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2511                    throws com.liferay.portal.kernel.exception.SystemException,
2512                            com.liferay.portlet.messageboards.NoSuchThreadException {
2513                    return getPersistence()
2514                                       .findByG_C_S_First(groupId, categoryId, status,
2515                            orderByComparator);
2516            }
2517    
2518            /**
2519            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
2520            *
2521            * @param groupId the group ID
2522            * @param categoryId the category ID
2523            * @param status the status
2524            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2525            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
2526            * @throws SystemException if a system exception occurred
2527            */
2528            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_S_First(
2529                    long groupId, long categoryId, int status,
2530                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2531                    throws com.liferay.portal.kernel.exception.SystemException {
2532                    return getPersistence()
2533                                       .fetchByG_C_S_First(groupId, categoryId, status,
2534                            orderByComparator);
2535            }
2536    
2537            /**
2538            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
2539            *
2540            * @param groupId the group ID
2541            * @param categoryId the category ID
2542            * @param status the status
2543            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2544            * @return the last matching message boards thread
2545            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
2546            * @throws SystemException if a system exception occurred
2547            */
2548            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_S_Last(
2549                    long groupId, long categoryId, int status,
2550                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2551                    throws com.liferay.portal.kernel.exception.SystemException,
2552                            com.liferay.portlet.messageboards.NoSuchThreadException {
2553                    return getPersistence()
2554                                       .findByG_C_S_Last(groupId, categoryId, status,
2555                            orderByComparator);
2556            }
2557    
2558            /**
2559            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
2560            *
2561            * @param groupId the group ID
2562            * @param categoryId the category ID
2563            * @param status the status
2564            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2565            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
2566            * @throws SystemException if a system exception occurred
2567            */
2568            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_S_Last(
2569                    long groupId, long categoryId, int status,
2570                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2571                    throws com.liferay.portal.kernel.exception.SystemException {
2572                    return getPersistence()
2573                                       .fetchByG_C_S_Last(groupId, categoryId, status,
2574                            orderByComparator);
2575            }
2576    
2577            /**
2578            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
2579            *
2580            * @param threadId the primary key of the current message boards thread
2581            * @param groupId the group ID
2582            * @param categoryId the category ID
2583            * @param status the status
2584            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2585            * @return the previous, current, and next message boards thread
2586            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
2587            * @throws SystemException if a system exception occurred
2588            */
2589            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_S_PrevAndNext(
2590                    long threadId, long groupId, long categoryId, int status,
2591                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2592                    throws com.liferay.portal.kernel.exception.SystemException,
2593                            com.liferay.portlet.messageboards.NoSuchThreadException {
2594                    return getPersistence()
2595                                       .findByG_C_S_PrevAndNext(threadId, groupId, categoryId,
2596                            status, orderByComparator);
2597            }
2598    
2599            /**
2600            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
2601            *
2602            * @param groupId the group ID
2603            * @param categoryId the category ID
2604            * @param status the status
2605            * @return the matching message boards threads that the user has permission to view
2606            * @throws SystemException if a system exception occurred
2607            */
2608            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2609                    long groupId, long categoryId, int status)
2610                    throws com.liferay.portal.kernel.exception.SystemException {
2611                    return getPersistence().filterFindByG_C_S(groupId, categoryId, status);
2612            }
2613    
2614            /**
2615            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
2616            *
2617            * <p>
2618            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2619            * </p>
2620            *
2621            * @param groupId the group ID
2622            * @param categoryId the category ID
2623            * @param status the status
2624            * @param start the lower bound of the range of message boards threads
2625            * @param end the upper bound of the range of message boards threads (not inclusive)
2626            * @return the range of matching message boards threads that the user has permission to view
2627            * @throws SystemException if a system exception occurred
2628            */
2629            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2630                    long groupId, long categoryId, int status, int start, int end)
2631                    throws com.liferay.portal.kernel.exception.SystemException {
2632                    return getPersistence()
2633                                       .filterFindByG_C_S(groupId, categoryId, status, start, end);
2634            }
2635    
2636            /**
2637            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
2638            *
2639            * <p>
2640            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2641            * </p>
2642            *
2643            * @param groupId the group ID
2644            * @param categoryId the category ID
2645            * @param status the status
2646            * @param start the lower bound of the range of message boards threads
2647            * @param end the upper bound of the range of message boards threads (not inclusive)
2648            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2649            * @return the ordered range of matching message boards threads that the user has permission to view
2650            * @throws SystemException if a system exception occurred
2651            */
2652            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2653                    long groupId, long categoryId, int status, int start, int end,
2654                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2655                    throws com.liferay.portal.kernel.exception.SystemException {
2656                    return getPersistence()
2657                                       .filterFindByG_C_S(groupId, categoryId, status, start, end,
2658                            orderByComparator);
2659            }
2660    
2661            /**
2662            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
2663            *
2664            * @param threadId the primary key of the current message boards thread
2665            * @param groupId the group ID
2666            * @param categoryId the category ID
2667            * @param status the status
2668            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2669            * @return the previous, current, and next message boards thread
2670            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
2671            * @throws SystemException if a system exception occurred
2672            */
2673            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_S_PrevAndNext(
2674                    long threadId, long groupId, long categoryId, int status,
2675                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2676                    throws com.liferay.portal.kernel.exception.SystemException,
2677                            com.liferay.portlet.messageboards.NoSuchThreadException {
2678                    return getPersistence()
2679                                       .filterFindByG_C_S_PrevAndNext(threadId, groupId,
2680                            categoryId, status, orderByComparator);
2681            }
2682    
2683            /**
2684            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2685            *
2686            * @param groupId the group ID
2687            * @param categoryIds the category IDs
2688            * @param status the status
2689            * @return the matching message boards threads that the user has permission to view
2690            * @throws SystemException if a system exception occurred
2691            */
2692            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2693                    long groupId, long[] categoryIds, int status)
2694                    throws com.liferay.portal.kernel.exception.SystemException {
2695                    return getPersistence().filterFindByG_C_S(groupId, categoryIds, status);
2696            }
2697    
2698            /**
2699            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2700            *
2701            * <p>
2702            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2703            * </p>
2704            *
2705            * @param groupId the group ID
2706            * @param categoryIds the category IDs
2707            * @param status the status
2708            * @param start the lower bound of the range of message boards threads
2709            * @param end the upper bound of the range of message boards threads (not inclusive)
2710            * @return the range of matching message boards threads that the user has permission to view
2711            * @throws SystemException if a system exception occurred
2712            */
2713            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2714                    long groupId, long[] categoryIds, int status, int start, int end)
2715                    throws com.liferay.portal.kernel.exception.SystemException {
2716                    return getPersistence()
2717                                       .filterFindByG_C_S(groupId, categoryIds, status, start, end);
2718            }
2719    
2720            /**
2721            * Returns an ordered range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2722            *
2723            * <p>
2724            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2725            * </p>
2726            *
2727            * @param groupId the group ID
2728            * @param categoryIds the category IDs
2729            * @param status the status
2730            * @param start the lower bound of the range of message boards threads
2731            * @param end the upper bound of the range of message boards threads (not inclusive)
2732            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2733            * @return the ordered range of matching message boards threads that the user has permission to view
2734            * @throws SystemException if a system exception occurred
2735            */
2736            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_S(
2737                    long groupId, long[] categoryIds, int status, int start, int end,
2738                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2739                    throws com.liferay.portal.kernel.exception.SystemException {
2740                    return getPersistence()
2741                                       .filterFindByG_C_S(groupId, categoryIds, status, start, end,
2742                            orderByComparator);
2743            }
2744    
2745            /**
2746            * Returns all the message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2747            *
2748            * <p>
2749            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2750            * </p>
2751            *
2752            * @param groupId the group ID
2753            * @param categoryIds the category IDs
2754            * @param status the status
2755            * @return the matching message boards threads
2756            * @throws SystemException if a system exception occurred
2757            */
2758            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
2759                    long groupId, long[] categoryIds, int status)
2760                    throws com.liferay.portal.kernel.exception.SystemException {
2761                    return getPersistence().findByG_C_S(groupId, categoryIds, status);
2762            }
2763    
2764            /**
2765            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2766            *
2767            * <p>
2768            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2769            * </p>
2770            *
2771            * @param groupId the group ID
2772            * @param categoryIds the category IDs
2773            * @param status the status
2774            * @param start the lower bound of the range of message boards threads
2775            * @param end the upper bound of the range of message boards threads (not inclusive)
2776            * @return the range of matching message boards threads
2777            * @throws SystemException if a system exception occurred
2778            */
2779            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
2780                    long groupId, long[] categoryIds, int status, int start, int end)
2781                    throws com.liferay.portal.kernel.exception.SystemException {
2782                    return getPersistence()
2783                                       .findByG_C_S(groupId, categoryIds, status, start, end);
2784            }
2785    
2786            /**
2787            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2788            *
2789            * <p>
2790            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2791            * </p>
2792            *
2793            * @param groupId the group ID
2794            * @param categoryIds the category IDs
2795            * @param status the status
2796            * @param start the lower bound of the range of message boards threads
2797            * @param end the upper bound of the range of message boards threads (not inclusive)
2798            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2799            * @return the ordered range of matching message boards threads
2800            * @throws SystemException if a system exception occurred
2801            */
2802            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_S(
2803                    long groupId, long[] categoryIds, int status, int start, int end,
2804                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2805                    throws com.liferay.portal.kernel.exception.SystemException {
2806                    return getPersistence()
2807                                       .findByG_C_S(groupId, categoryIds, status, start, end,
2808                            orderByComparator);
2809            }
2810    
2811            /**
2812            * Removes all the message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63; from the database.
2813            *
2814            * @param groupId the group ID
2815            * @param categoryId the category ID
2816            * @param status the status
2817            * @throws SystemException if a system exception occurred
2818            */
2819            public static void removeByG_C_S(long groupId, long categoryId, int status)
2820                    throws com.liferay.portal.kernel.exception.SystemException {
2821                    getPersistence().removeByG_C_S(groupId, categoryId, status);
2822            }
2823    
2824            /**
2825            * Returns the number of message boards threads where groupId = &#63; and categoryId = &#63; and status = &#63;.
2826            *
2827            * @param groupId the group ID
2828            * @param categoryId the category ID
2829            * @param status the status
2830            * @return the number of matching message boards threads
2831            * @throws SystemException if a system exception occurred
2832            */
2833            public static int countByG_C_S(long groupId, long categoryId, int status)
2834                    throws com.liferay.portal.kernel.exception.SystemException {
2835                    return getPersistence().countByG_C_S(groupId, categoryId, status);
2836            }
2837    
2838            /**
2839            * Returns the number of message boards threads where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2840            *
2841            * @param groupId the group ID
2842            * @param categoryIds the category IDs
2843            * @param status the status
2844            * @return the number of matching message boards threads
2845            * @throws SystemException if a system exception occurred
2846            */
2847            public static int countByG_C_S(long groupId, long[] categoryIds, int status)
2848                    throws com.liferay.portal.kernel.exception.SystemException {
2849                    return getPersistence().countByG_C_S(groupId, categoryIds, status);
2850            }
2851    
2852            /**
2853            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
2854            *
2855            * @param groupId the group ID
2856            * @param categoryId the category ID
2857            * @param status the status
2858            * @return the number of matching message boards threads that the user has permission to view
2859            * @throws SystemException if a system exception occurred
2860            */
2861            public static int filterCountByG_C_S(long groupId, long categoryId,
2862                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2863                    return getPersistence().filterCountByG_C_S(groupId, categoryId, status);
2864            }
2865    
2866            /**
2867            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status = &#63;.
2868            *
2869            * @param groupId the group ID
2870            * @param categoryIds the category IDs
2871            * @param status the status
2872            * @return the number of matching message boards threads that the user has permission to view
2873            * @throws SystemException if a system exception occurred
2874            */
2875            public static int filterCountByG_C_S(long groupId, long[] categoryIds,
2876                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2877                    return getPersistence().filterCountByG_C_S(groupId, categoryIds, status);
2878            }
2879    
2880            /**
2881            * Returns all the message boards threads where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
2882            *
2883            * @param groupId the group ID
2884            * @param categoryId the category ID
2885            * @param status the status
2886            * @return the matching message boards threads
2887            * @throws SystemException if a system exception occurred
2888            */
2889            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS(
2890                    long groupId, long categoryId, int status)
2891                    throws com.liferay.portal.kernel.exception.SystemException {
2892                    return getPersistence().findByG_C_NotS(groupId, categoryId, status);
2893            }
2894    
2895            /**
2896            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
2897            *
2898            * <p>
2899            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2900            * </p>
2901            *
2902            * @param groupId the group ID
2903            * @param categoryId the category ID
2904            * @param status the status
2905            * @param start the lower bound of the range of message boards threads
2906            * @param end the upper bound of the range of message boards threads (not inclusive)
2907            * @return the range of matching message boards threads
2908            * @throws SystemException if a system exception occurred
2909            */
2910            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS(
2911                    long groupId, long categoryId, int status, int start, int end)
2912                    throws com.liferay.portal.kernel.exception.SystemException {
2913                    return getPersistence()
2914                                       .findByG_C_NotS(groupId, categoryId, status, start, end);
2915            }
2916    
2917            /**
2918            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
2919            *
2920            * <p>
2921            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2922            * </p>
2923            *
2924            * @param groupId the group ID
2925            * @param categoryId the category ID
2926            * @param status the status
2927            * @param start the lower bound of the range of message boards threads
2928            * @param end the upper bound of the range of message boards threads (not inclusive)
2929            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2930            * @return the ordered range of matching message boards threads
2931            * @throws SystemException if a system exception occurred
2932            */
2933            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS(
2934                    long groupId, long categoryId, int status, int start, int end,
2935                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2936                    throws com.liferay.portal.kernel.exception.SystemException {
2937                    return getPersistence()
2938                                       .findByG_C_NotS(groupId, categoryId, status, start, end,
2939                            orderByComparator);
2940            }
2941    
2942            /**
2943            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
2944            *
2945            * @param groupId the group ID
2946            * @param categoryId the category ID
2947            * @param status the status
2948            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2949            * @return the first matching message boards thread
2950            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
2951            * @throws SystemException if a system exception occurred
2952            */
2953            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_NotS_First(
2954                    long groupId, long categoryId, int status,
2955                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2956                    throws com.liferay.portal.kernel.exception.SystemException,
2957                            com.liferay.portlet.messageboards.NoSuchThreadException {
2958                    return getPersistence()
2959                                       .findByG_C_NotS_First(groupId, categoryId, status,
2960                            orderByComparator);
2961            }
2962    
2963            /**
2964            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
2965            *
2966            * @param groupId the group ID
2967            * @param categoryId the category ID
2968            * @param status the status
2969            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2970            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
2971            * @throws SystemException if a system exception occurred
2972            */
2973            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_NotS_First(
2974                    long groupId, long categoryId, int status,
2975                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2976                    throws com.liferay.portal.kernel.exception.SystemException {
2977                    return getPersistence()
2978                                       .fetchByG_C_NotS_First(groupId, categoryId, status,
2979                            orderByComparator);
2980            }
2981    
2982            /**
2983            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
2984            *
2985            * @param groupId the group ID
2986            * @param categoryId the category ID
2987            * @param status the status
2988            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2989            * @return the last matching message boards thread
2990            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
2991            * @throws SystemException if a system exception occurred
2992            */
2993            public static com.liferay.portlet.messageboards.model.MBThread findByG_C_NotS_Last(
2994                    long groupId, long categoryId, int status,
2995                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2996                    throws com.liferay.portal.kernel.exception.SystemException,
2997                            com.liferay.portlet.messageboards.NoSuchThreadException {
2998                    return getPersistence()
2999                                       .findByG_C_NotS_Last(groupId, categoryId, status,
3000                            orderByComparator);
3001            }
3002    
3003            /**
3004            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
3005            *
3006            * @param groupId the group ID
3007            * @param categoryId the category ID
3008            * @param status the status
3009            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3010            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
3011            * @throws SystemException if a system exception occurred
3012            */
3013            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_C_NotS_Last(
3014                    long groupId, long categoryId, int status,
3015                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3016                    throws com.liferay.portal.kernel.exception.SystemException {
3017                    return getPersistence()
3018                                       .fetchByG_C_NotS_Last(groupId, categoryId, status,
3019                            orderByComparator);
3020            }
3021    
3022            /**
3023            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
3024            *
3025            * @param threadId the primary key of the current message boards thread
3026            * @param groupId the group ID
3027            * @param categoryId the category ID
3028            * @param status the status
3029            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3030            * @return the previous, current, and next message boards thread
3031            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
3032            * @throws SystemException if a system exception occurred
3033            */
3034            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_C_NotS_PrevAndNext(
3035                    long threadId, long groupId, long categoryId, int status,
3036                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3037                    throws com.liferay.portal.kernel.exception.SystemException,
3038                            com.liferay.portlet.messageboards.NoSuchThreadException {
3039                    return getPersistence()
3040                                       .findByG_C_NotS_PrevAndNext(threadId, groupId, categoryId,
3041                            status, orderByComparator);
3042            }
3043    
3044            /**
3045            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
3046            *
3047            * @param groupId the group ID
3048            * @param categoryId the category ID
3049            * @param status the status
3050            * @return the matching message boards threads that the user has permission to view
3051            * @throws SystemException if a system exception occurred
3052            */
3053            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS(
3054                    long groupId, long categoryId, int status)
3055                    throws com.liferay.portal.kernel.exception.SystemException {
3056                    return getPersistence().filterFindByG_C_NotS(groupId, categoryId, status);
3057            }
3058    
3059            /**
3060            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
3061            *
3062            * <p>
3063            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3064            * </p>
3065            *
3066            * @param groupId the group ID
3067            * @param categoryId the category ID
3068            * @param status the status
3069            * @param start the lower bound of the range of message boards threads
3070            * @param end the upper bound of the range of message boards threads (not inclusive)
3071            * @return the range of matching message boards threads that the user has permission to view
3072            * @throws SystemException if a system exception occurred
3073            */
3074            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS(
3075                    long groupId, long categoryId, int status, int start, int end)
3076                    throws com.liferay.portal.kernel.exception.SystemException {
3077                    return getPersistence()
3078                                       .filterFindByG_C_NotS(groupId, categoryId, status, start, end);
3079            }
3080    
3081            /**
3082            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
3083            *
3084            * <p>
3085            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3086            * </p>
3087            *
3088            * @param groupId the group ID
3089            * @param categoryId the category ID
3090            * @param status the status
3091            * @param start the lower bound of the range of message boards threads
3092            * @param end the upper bound of the range of message boards threads (not inclusive)
3093            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3094            * @return the ordered range of matching message boards threads that the user has permission to view
3095            * @throws SystemException if a system exception occurred
3096            */
3097            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS(
3098                    long groupId, long categoryId, int status, int start, int end,
3099                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3100                    throws com.liferay.portal.kernel.exception.SystemException {
3101                    return getPersistence()
3102                                       .filterFindByG_C_NotS(groupId, categoryId, status, start,
3103                            end, orderByComparator);
3104            }
3105    
3106            /**
3107            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
3108            *
3109            * @param threadId the primary key of the current message boards thread
3110            * @param groupId the group ID
3111            * @param categoryId the category ID
3112            * @param status the status
3113            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3114            * @return the previous, current, and next message boards thread
3115            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
3116            * @throws SystemException if a system exception occurred
3117            */
3118            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_C_NotS_PrevAndNext(
3119                    long threadId, long groupId, long categoryId, int status,
3120                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3121                    throws com.liferay.portal.kernel.exception.SystemException,
3122                            com.liferay.portlet.messageboards.NoSuchThreadException {
3123                    return getPersistence()
3124                                       .filterFindByG_C_NotS_PrevAndNext(threadId, groupId,
3125                            categoryId, status, orderByComparator);
3126            }
3127    
3128            /**
3129            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status &ne; &#63;.
3130            *
3131            * @param groupId the group ID
3132            * @param categoryIds the category IDs
3133            * @param status the status
3134            * @return the matching message boards threads that the user has permission to view
3135            * @throws SystemException if a system exception occurred
3136            */
3137            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS(
3138                    long groupId, long[] categoryIds, int status)
3139                    throws com.liferay.portal.kernel.exception.SystemException {
3140                    return getPersistence()
3141                                       .filterFindByG_C_NotS(groupId, categoryIds, status);
3142            }
3143    
3144            /**
3145            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status &ne; &#63;.
3146            *
3147            * <p>
3148            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3149            * </p>
3150            *
3151            * @param groupId the group ID
3152            * @param categoryIds the category IDs
3153            * @param status the status
3154            * @param start the lower bound of the range of message boards threads
3155            * @param end the upper bound of the range of message boards threads (not inclusive)
3156            * @return the range of matching message boards threads that the user has permission to view
3157            * @throws SystemException if a system exception occurred
3158            */
3159            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS(
3160                    long groupId, long[] categoryIds, int status, int start, int end)
3161                    throws com.liferay.portal.kernel.exception.SystemException {
3162                    return getPersistence()
3163                                       .filterFindByG_C_NotS(groupId, categoryIds, status, start,
3164                            end);
3165            }
3166    
3167            /**
3168            * Returns an ordered range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status &ne; &#63;.
3169            *
3170            * <p>
3171            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3172            * </p>
3173            *
3174            * @param groupId the group ID
3175            * @param categoryIds the category IDs
3176            * @param status the status
3177            * @param start the lower bound of the range of message boards threads
3178            * @param end the upper bound of the range of message boards threads (not inclusive)
3179            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3180            * @return the ordered range of matching message boards threads that the user has permission to view
3181            * @throws SystemException if a system exception occurred
3182            */
3183            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_C_NotS(
3184                    long groupId, long[] categoryIds, int status, int start, int end,
3185                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3186                    throws com.liferay.portal.kernel.exception.SystemException {
3187                    return getPersistence()
3188                                       .filterFindByG_C_NotS(groupId, categoryIds, status, start,
3189                            end, orderByComparator);
3190            }
3191    
3192            /**
3193            * Returns all the message boards threads where groupId = &#63; and categoryId = any &#63; and status &ne; &#63;.
3194            *
3195            * <p>
3196            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3197            * </p>
3198            *
3199            * @param groupId the group ID
3200            * @param categoryIds the category IDs
3201            * @param status the status
3202            * @return the matching message boards threads
3203            * @throws SystemException if a system exception occurred
3204            */
3205            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS(
3206                    long groupId, long[] categoryIds, int status)
3207                    throws com.liferay.portal.kernel.exception.SystemException {
3208                    return getPersistence().findByG_C_NotS(groupId, categoryIds, status);
3209            }
3210    
3211            /**
3212            * Returns a range of all the message boards threads where groupId = &#63; and categoryId = any &#63; and status &ne; &#63;.
3213            *
3214            * <p>
3215            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3216            * </p>
3217            *
3218            * @param groupId the group ID
3219            * @param categoryIds the category IDs
3220            * @param status the status
3221            * @param start the lower bound of the range of message boards threads
3222            * @param end the upper bound of the range of message boards threads (not inclusive)
3223            * @return the range of matching message boards threads
3224            * @throws SystemException if a system exception occurred
3225            */
3226            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS(
3227                    long groupId, long[] categoryIds, int status, int start, int end)
3228                    throws com.liferay.portal.kernel.exception.SystemException {
3229                    return getPersistence()
3230                                       .findByG_C_NotS(groupId, categoryIds, status, start, end);
3231            }
3232    
3233            /**
3234            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId = any &#63; and status &ne; &#63;.
3235            *
3236            * <p>
3237            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3238            * </p>
3239            *
3240            * @param groupId the group ID
3241            * @param categoryIds the category IDs
3242            * @param status the status
3243            * @param start the lower bound of the range of message boards threads
3244            * @param end the upper bound of the range of message boards threads (not inclusive)
3245            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3246            * @return the ordered range of matching message boards threads
3247            * @throws SystemException if a system exception occurred
3248            */
3249            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_C_NotS(
3250                    long groupId, long[] categoryIds, int status, int start, int end,
3251                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3252                    throws com.liferay.portal.kernel.exception.SystemException {
3253                    return getPersistence()
3254                                       .findByG_C_NotS(groupId, categoryIds, status, start, end,
3255                            orderByComparator);
3256            }
3257    
3258            /**
3259            * Removes all the message boards threads where groupId = &#63; and categoryId = &#63; and status &ne; &#63; from the database.
3260            *
3261            * @param groupId the group ID
3262            * @param categoryId the category ID
3263            * @param status the status
3264            * @throws SystemException if a system exception occurred
3265            */
3266            public static void removeByG_C_NotS(long groupId, long categoryId,
3267                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3268                    getPersistence().removeByG_C_NotS(groupId, categoryId, status);
3269            }
3270    
3271            /**
3272            * Returns the number of message boards threads where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
3273            *
3274            * @param groupId the group ID
3275            * @param categoryId the category ID
3276            * @param status the status
3277            * @return the number of matching message boards threads
3278            * @throws SystemException if a system exception occurred
3279            */
3280            public static int countByG_C_NotS(long groupId, long categoryId, int status)
3281                    throws com.liferay.portal.kernel.exception.SystemException {
3282                    return getPersistence().countByG_C_NotS(groupId, categoryId, status);
3283            }
3284    
3285            /**
3286            * Returns the number of message boards threads where groupId = &#63; and categoryId = any &#63; and status &ne; &#63;.
3287            *
3288            * @param groupId the group ID
3289            * @param categoryIds the category IDs
3290            * @param status the status
3291            * @return the number of matching message boards threads
3292            * @throws SystemException if a system exception occurred
3293            */
3294            public static int countByG_C_NotS(long groupId, long[] categoryIds,
3295                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3296                    return getPersistence().countByG_C_NotS(groupId, categoryIds, status);
3297            }
3298    
3299            /**
3300            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = &#63; and status &ne; &#63;.
3301            *
3302            * @param groupId the group ID
3303            * @param categoryId the category ID
3304            * @param status the status
3305            * @return the number of matching message boards threads that the user has permission to view
3306            * @throws SystemException if a system exception occurred
3307            */
3308            public static int filterCountByG_C_NotS(long groupId, long categoryId,
3309                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3310                    return getPersistence()
3311                                       .filterCountByG_C_NotS(groupId, categoryId, status);
3312            }
3313    
3314            /**
3315            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId = any &#63; and status &ne; &#63;.
3316            *
3317            * @param groupId the group ID
3318            * @param categoryIds the category IDs
3319            * @param status the status
3320            * @return the number of matching message boards threads that the user has permission to view
3321            * @throws SystemException if a system exception occurred
3322            */
3323            public static int filterCountByG_C_NotS(long groupId, long[] categoryIds,
3324                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3325                    return getPersistence()
3326                                       .filterCountByG_C_NotS(groupId, categoryIds, status);
3327            }
3328    
3329            /**
3330            * Returns all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3331            *
3332            * @param groupId the group ID
3333            * @param categoryId the category ID
3334            * @param status the status
3335            * @return the matching message boards threads
3336            * @throws SystemException if a system exception occurred
3337            */
3338            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S(
3339                    long groupId, long categoryId, int status)
3340                    throws com.liferay.portal.kernel.exception.SystemException {
3341                    return getPersistence().findByG_NotC_S(groupId, categoryId, status);
3342            }
3343    
3344            /**
3345            * Returns a range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3346            *
3347            * <p>
3348            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3349            * </p>
3350            *
3351            * @param groupId the group ID
3352            * @param categoryId the category ID
3353            * @param status the status
3354            * @param start the lower bound of the range of message boards threads
3355            * @param end the upper bound of the range of message boards threads (not inclusive)
3356            * @return the range of matching message boards threads
3357            * @throws SystemException if a system exception occurred
3358            */
3359            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S(
3360                    long groupId, long categoryId, int status, int start, int end)
3361                    throws com.liferay.portal.kernel.exception.SystemException {
3362                    return getPersistence()
3363                                       .findByG_NotC_S(groupId, categoryId, status, start, end);
3364            }
3365    
3366            /**
3367            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3368            *
3369            * <p>
3370            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3371            * </p>
3372            *
3373            * @param groupId the group ID
3374            * @param categoryId the category ID
3375            * @param status the status
3376            * @param start the lower bound of the range of message boards threads
3377            * @param end the upper bound of the range of message boards threads (not inclusive)
3378            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3379            * @return the ordered range of matching message boards threads
3380            * @throws SystemException if a system exception occurred
3381            */
3382            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_S(
3383                    long groupId, long categoryId, int status, int start, int end,
3384                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3385                    throws com.liferay.portal.kernel.exception.SystemException {
3386                    return getPersistence()
3387                                       .findByG_NotC_S(groupId, categoryId, status, start, end,
3388                            orderByComparator);
3389            }
3390    
3391            /**
3392            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3393            *
3394            * @param groupId the group ID
3395            * @param categoryId the category ID
3396            * @param status the status
3397            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3398            * @return the first matching message boards thread
3399            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
3400            * @throws SystemException if a system exception occurred
3401            */
3402            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_First(
3403                    long groupId, long categoryId, int status,
3404                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3405                    throws com.liferay.portal.kernel.exception.SystemException,
3406                            com.liferay.portlet.messageboards.NoSuchThreadException {
3407                    return getPersistence()
3408                                       .findByG_NotC_S_First(groupId, categoryId, status,
3409                            orderByComparator);
3410            }
3411    
3412            /**
3413            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3414            *
3415            * @param groupId the group ID
3416            * @param categoryId the category ID
3417            * @param status the status
3418            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3419            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
3420            * @throws SystemException if a system exception occurred
3421            */
3422            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_S_First(
3423                    long groupId, long categoryId, int status,
3424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3425                    throws com.liferay.portal.kernel.exception.SystemException {
3426                    return getPersistence()
3427                                       .fetchByG_NotC_S_First(groupId, categoryId, status,
3428                            orderByComparator);
3429            }
3430    
3431            /**
3432            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3433            *
3434            * @param groupId the group ID
3435            * @param categoryId the category ID
3436            * @param status the status
3437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3438            * @return the last matching message boards thread
3439            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
3440            * @throws SystemException if a system exception occurred
3441            */
3442            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_S_Last(
3443                    long groupId, long categoryId, int status,
3444                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3445                    throws com.liferay.portal.kernel.exception.SystemException,
3446                            com.liferay.portlet.messageboards.NoSuchThreadException {
3447                    return getPersistence()
3448                                       .findByG_NotC_S_Last(groupId, categoryId, status,
3449                            orderByComparator);
3450            }
3451    
3452            /**
3453            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3454            *
3455            * @param groupId the group ID
3456            * @param categoryId the category ID
3457            * @param status the status
3458            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3459            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
3460            * @throws SystemException if a system exception occurred
3461            */
3462            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_S_Last(
3463                    long groupId, long categoryId, int status,
3464                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3465                    throws com.liferay.portal.kernel.exception.SystemException {
3466                    return getPersistence()
3467                                       .fetchByG_NotC_S_Last(groupId, categoryId, status,
3468                            orderByComparator);
3469            }
3470    
3471            /**
3472            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3473            *
3474            * @param threadId the primary key of the current message boards thread
3475            * @param groupId the group ID
3476            * @param categoryId the category ID
3477            * @param status the status
3478            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3479            * @return the previous, current, and next message boards thread
3480            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
3481            * @throws SystemException if a system exception occurred
3482            */
3483            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_S_PrevAndNext(
3484                    long threadId, long groupId, long categoryId, int status,
3485                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3486                    throws com.liferay.portal.kernel.exception.SystemException,
3487                            com.liferay.portlet.messageboards.NoSuchThreadException {
3488                    return getPersistence()
3489                                       .findByG_NotC_S_PrevAndNext(threadId, groupId, categoryId,
3490                            status, orderByComparator);
3491            }
3492    
3493            /**
3494            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3495            *
3496            * @param groupId the group ID
3497            * @param categoryId the category ID
3498            * @param status the status
3499            * @return the matching message boards threads that the user has permission to view
3500            * @throws SystemException if a system exception occurred
3501            */
3502            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S(
3503                    long groupId, long categoryId, int status)
3504                    throws com.liferay.portal.kernel.exception.SystemException {
3505                    return getPersistence().filterFindByG_NotC_S(groupId, categoryId, status);
3506            }
3507    
3508            /**
3509            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3510            *
3511            * <p>
3512            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3513            * </p>
3514            *
3515            * @param groupId the group ID
3516            * @param categoryId the category ID
3517            * @param status the status
3518            * @param start the lower bound of the range of message boards threads
3519            * @param end the upper bound of the range of message boards threads (not inclusive)
3520            * @return the range of matching message boards threads that the user has permission to view
3521            * @throws SystemException if a system exception occurred
3522            */
3523            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S(
3524                    long groupId, long categoryId, int status, int start, int end)
3525                    throws com.liferay.portal.kernel.exception.SystemException {
3526                    return getPersistence()
3527                                       .filterFindByG_NotC_S(groupId, categoryId, status, start, end);
3528            }
3529    
3530            /**
3531            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3532            *
3533            * <p>
3534            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3535            * </p>
3536            *
3537            * @param groupId the group ID
3538            * @param categoryId the category ID
3539            * @param status the status
3540            * @param start the lower bound of the range of message boards threads
3541            * @param end the upper bound of the range of message boards threads (not inclusive)
3542            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3543            * @return the ordered range of matching message boards threads that the user has permission to view
3544            * @throws SystemException if a system exception occurred
3545            */
3546            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_S(
3547                    long groupId, long categoryId, int status, int start, int end,
3548                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3549                    throws com.liferay.portal.kernel.exception.SystemException {
3550                    return getPersistence()
3551                                       .filterFindByG_NotC_S(groupId, categoryId, status, start,
3552                            end, orderByComparator);
3553            }
3554    
3555            /**
3556            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3557            *
3558            * @param threadId the primary key of the current message boards thread
3559            * @param groupId the group ID
3560            * @param categoryId the category ID
3561            * @param status the status
3562            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3563            * @return the previous, current, and next message boards thread
3564            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
3565            * @throws SystemException if a system exception occurred
3566            */
3567            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_NotC_S_PrevAndNext(
3568                    long threadId, long groupId, long categoryId, int status,
3569                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3570                    throws com.liferay.portal.kernel.exception.SystemException,
3571                            com.liferay.portlet.messageboards.NoSuchThreadException {
3572                    return getPersistence()
3573                                       .filterFindByG_NotC_S_PrevAndNext(threadId, groupId,
3574                            categoryId, status, orderByComparator);
3575            }
3576    
3577            /**
3578            * Removes all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63; from the database.
3579            *
3580            * @param groupId the group ID
3581            * @param categoryId the category ID
3582            * @param status the status
3583            * @throws SystemException if a system exception occurred
3584            */
3585            public static void removeByG_NotC_S(long groupId, long categoryId,
3586                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3587                    getPersistence().removeByG_NotC_S(groupId, categoryId, status);
3588            }
3589    
3590            /**
3591            * Returns the number of message boards threads where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3592            *
3593            * @param groupId the group ID
3594            * @param categoryId the category ID
3595            * @param status the status
3596            * @return the number of matching message boards threads
3597            * @throws SystemException if a system exception occurred
3598            */
3599            public static int countByG_NotC_S(long groupId, long categoryId, int status)
3600                    throws com.liferay.portal.kernel.exception.SystemException {
3601                    return getPersistence().countByG_NotC_S(groupId, categoryId, status);
3602            }
3603    
3604            /**
3605            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status = &#63;.
3606            *
3607            * @param groupId the group ID
3608            * @param categoryId the category ID
3609            * @param status the status
3610            * @return the number of matching message boards threads that the user has permission to view
3611            * @throws SystemException if a system exception occurred
3612            */
3613            public static int filterCountByG_NotC_S(long groupId, long categoryId,
3614                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3615                    return getPersistence()
3616                                       .filterCountByG_NotC_S(groupId, categoryId, status);
3617            }
3618    
3619            /**
3620            * Returns all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3621            *
3622            * @param groupId the group ID
3623            * @param categoryId the category ID
3624            * @param status the status
3625            * @return the matching message boards threads
3626            * @throws SystemException if a system exception occurred
3627            */
3628            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_NotS(
3629                    long groupId, long categoryId, int status)
3630                    throws com.liferay.portal.kernel.exception.SystemException {
3631                    return getPersistence().findByG_NotC_NotS(groupId, categoryId, status);
3632            }
3633    
3634            /**
3635            * Returns a range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3636            *
3637            * <p>
3638            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3639            * </p>
3640            *
3641            * @param groupId the group ID
3642            * @param categoryId the category ID
3643            * @param status the status
3644            * @param start the lower bound of the range of message boards threads
3645            * @param end the upper bound of the range of message boards threads (not inclusive)
3646            * @return the range of matching message boards threads
3647            * @throws SystemException if a system exception occurred
3648            */
3649            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_NotS(
3650                    long groupId, long categoryId, int status, int start, int end)
3651                    throws com.liferay.portal.kernel.exception.SystemException {
3652                    return getPersistence()
3653                                       .findByG_NotC_NotS(groupId, categoryId, status, start, end);
3654            }
3655    
3656            /**
3657            * Returns an ordered range of all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3658            *
3659            * <p>
3660            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3661            * </p>
3662            *
3663            * @param groupId the group ID
3664            * @param categoryId the category ID
3665            * @param status the status
3666            * @param start the lower bound of the range of message boards threads
3667            * @param end the upper bound of the range of message boards threads (not inclusive)
3668            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3669            * @return the ordered range of matching message boards threads
3670            * @throws SystemException if a system exception occurred
3671            */
3672            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findByG_NotC_NotS(
3673                    long groupId, long categoryId, int status, int start, int end,
3674                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3675                    throws com.liferay.portal.kernel.exception.SystemException {
3676                    return getPersistence()
3677                                       .findByG_NotC_NotS(groupId, categoryId, status, start, end,
3678                            orderByComparator);
3679            }
3680    
3681            /**
3682            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3683            *
3684            * @param groupId the group ID
3685            * @param categoryId the category ID
3686            * @param status the status
3687            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3688            * @return the first matching message boards thread
3689            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
3690            * @throws SystemException if a system exception occurred
3691            */
3692            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_NotS_First(
3693                    long groupId, long categoryId, int status,
3694                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3695                    throws com.liferay.portal.kernel.exception.SystemException,
3696                            com.liferay.portlet.messageboards.NoSuchThreadException {
3697                    return getPersistence()
3698                                       .findByG_NotC_NotS_First(groupId, categoryId, status,
3699                            orderByComparator);
3700            }
3701    
3702            /**
3703            * Returns the first message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3704            *
3705            * @param groupId the group ID
3706            * @param categoryId the category ID
3707            * @param status the status
3708            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3709            * @return the first matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
3710            * @throws SystemException if a system exception occurred
3711            */
3712            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_NotS_First(
3713                    long groupId, long categoryId, int status,
3714                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3715                    throws com.liferay.portal.kernel.exception.SystemException {
3716                    return getPersistence()
3717                                       .fetchByG_NotC_NotS_First(groupId, categoryId, status,
3718                            orderByComparator);
3719            }
3720    
3721            /**
3722            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3723            *
3724            * @param groupId the group ID
3725            * @param categoryId the category ID
3726            * @param status the status
3727            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3728            * @return the last matching message boards thread
3729            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a matching message boards thread could not be found
3730            * @throws SystemException if a system exception occurred
3731            */
3732            public static com.liferay.portlet.messageboards.model.MBThread findByG_NotC_NotS_Last(
3733                    long groupId, long categoryId, int status,
3734                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3735                    throws com.liferay.portal.kernel.exception.SystemException,
3736                            com.liferay.portlet.messageboards.NoSuchThreadException {
3737                    return getPersistence()
3738                                       .findByG_NotC_NotS_Last(groupId, categoryId, status,
3739                            orderByComparator);
3740            }
3741    
3742            /**
3743            * Returns the last message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3744            *
3745            * @param groupId the group ID
3746            * @param categoryId the category ID
3747            * @param status the status
3748            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3749            * @return the last matching message boards thread, or <code>null</code> if a matching message boards thread could not be found
3750            * @throws SystemException if a system exception occurred
3751            */
3752            public static com.liferay.portlet.messageboards.model.MBThread fetchByG_NotC_NotS_Last(
3753                    long groupId, long categoryId, int status,
3754                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3755                    throws com.liferay.portal.kernel.exception.SystemException {
3756                    return getPersistence()
3757                                       .fetchByG_NotC_NotS_Last(groupId, categoryId, status,
3758                            orderByComparator);
3759            }
3760    
3761            /**
3762            * Returns the message boards threads before and after the current message boards thread in the ordered set where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3763            *
3764            * @param threadId the primary key of the current message boards thread
3765            * @param groupId the group ID
3766            * @param categoryId the category ID
3767            * @param status the status
3768            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3769            * @return the previous, current, and next message boards thread
3770            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
3771            * @throws SystemException if a system exception occurred
3772            */
3773            public static com.liferay.portlet.messageboards.model.MBThread[] findByG_NotC_NotS_PrevAndNext(
3774                    long threadId, long groupId, long categoryId, int status,
3775                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3776                    throws com.liferay.portal.kernel.exception.SystemException,
3777                            com.liferay.portlet.messageboards.NoSuchThreadException {
3778                    return getPersistence()
3779                                       .findByG_NotC_NotS_PrevAndNext(threadId, groupId,
3780                            categoryId, status, orderByComparator);
3781            }
3782    
3783            /**
3784            * Returns all the message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3785            *
3786            * @param groupId the group ID
3787            * @param categoryId the category ID
3788            * @param status the status
3789            * @return the matching message boards threads that the user has permission to view
3790            * @throws SystemException if a system exception occurred
3791            */
3792            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_NotS(
3793                    long groupId, long categoryId, int status)
3794                    throws com.liferay.portal.kernel.exception.SystemException {
3795                    return getPersistence()
3796                                       .filterFindByG_NotC_NotS(groupId, categoryId, status);
3797            }
3798    
3799            /**
3800            * Returns a range of all the message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3801            *
3802            * <p>
3803            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3804            * </p>
3805            *
3806            * @param groupId the group ID
3807            * @param categoryId the category ID
3808            * @param status the status
3809            * @param start the lower bound of the range of message boards threads
3810            * @param end the upper bound of the range of message boards threads (not inclusive)
3811            * @return the range of matching message boards threads that the user has permission to view
3812            * @throws SystemException if a system exception occurred
3813            */
3814            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_NotS(
3815                    long groupId, long categoryId, int status, int start, int end)
3816                    throws com.liferay.portal.kernel.exception.SystemException {
3817                    return getPersistence()
3818                                       .filterFindByG_NotC_NotS(groupId, categoryId, status, start,
3819                            end);
3820            }
3821    
3822            /**
3823            * Returns an ordered range of all the message boards threads that the user has permissions to view where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3824            *
3825            * <p>
3826            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3827            * </p>
3828            *
3829            * @param groupId the group ID
3830            * @param categoryId the category ID
3831            * @param status the status
3832            * @param start the lower bound of the range of message boards threads
3833            * @param end the upper bound of the range of message boards threads (not inclusive)
3834            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3835            * @return the ordered range of matching message boards threads that the user has permission to view
3836            * @throws SystemException if a system exception occurred
3837            */
3838            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> filterFindByG_NotC_NotS(
3839                    long groupId, long categoryId, int status, int start, int end,
3840                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3841                    throws com.liferay.portal.kernel.exception.SystemException {
3842                    return getPersistence()
3843                                       .filterFindByG_NotC_NotS(groupId, categoryId, status, start,
3844                            end, orderByComparator);
3845            }
3846    
3847            /**
3848            * Returns the message boards threads before and after the current message boards thread in the ordered set of message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3849            *
3850            * @param threadId the primary key of the current message boards thread
3851            * @param groupId the group ID
3852            * @param categoryId the category ID
3853            * @param status the status
3854            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3855            * @return the previous, current, and next message boards thread
3856            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
3857            * @throws SystemException if a system exception occurred
3858            */
3859            public static com.liferay.portlet.messageboards.model.MBThread[] filterFindByG_NotC_NotS_PrevAndNext(
3860                    long threadId, long groupId, long categoryId, int status,
3861                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3862                    throws com.liferay.portal.kernel.exception.SystemException,
3863                            com.liferay.portlet.messageboards.NoSuchThreadException {
3864                    return getPersistence()
3865                                       .filterFindByG_NotC_NotS_PrevAndNext(threadId, groupId,
3866                            categoryId, status, orderByComparator);
3867            }
3868    
3869            /**
3870            * Removes all the message boards threads where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63; from the database.
3871            *
3872            * @param groupId the group ID
3873            * @param categoryId the category ID
3874            * @param status the status
3875            * @throws SystemException if a system exception occurred
3876            */
3877            public static void removeByG_NotC_NotS(long groupId, long categoryId,
3878                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3879                    getPersistence().removeByG_NotC_NotS(groupId, categoryId, status);
3880            }
3881    
3882            /**
3883            * Returns the number of message boards threads where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3884            *
3885            * @param groupId the group ID
3886            * @param categoryId the category ID
3887            * @param status the status
3888            * @return the number of matching message boards threads
3889            * @throws SystemException if a system exception occurred
3890            */
3891            public static int countByG_NotC_NotS(long groupId, long categoryId,
3892                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3893                    return getPersistence().countByG_NotC_NotS(groupId, categoryId, status);
3894            }
3895    
3896            /**
3897            * Returns the number of message boards threads that the user has permission to view where groupId = &#63; and categoryId &ne; &#63; and status &ne; &#63;.
3898            *
3899            * @param groupId the group ID
3900            * @param categoryId the category ID
3901            * @param status the status
3902            * @return the number of matching message boards threads that the user has permission to view
3903            * @throws SystemException if a system exception occurred
3904            */
3905            public static int filterCountByG_NotC_NotS(long groupId, long categoryId,
3906                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3907                    return getPersistence()
3908                                       .filterCountByG_NotC_NotS(groupId, categoryId, status);
3909            }
3910    
3911            /**
3912            * Caches the message boards thread in the entity cache if it is enabled.
3913            *
3914            * @param mbThread the message boards thread
3915            */
3916            public static void cacheResult(
3917                    com.liferay.portlet.messageboards.model.MBThread mbThread) {
3918                    getPersistence().cacheResult(mbThread);
3919            }
3920    
3921            /**
3922            * Caches the message boards threads in the entity cache if it is enabled.
3923            *
3924            * @param mbThreads the message boards threads
3925            */
3926            public static void cacheResult(
3927                    java.util.List<com.liferay.portlet.messageboards.model.MBThread> mbThreads) {
3928                    getPersistence().cacheResult(mbThreads);
3929            }
3930    
3931            /**
3932            * Creates a new message boards thread with the primary key. Does not add the message boards thread to the database.
3933            *
3934            * @param threadId the primary key for the new message boards thread
3935            * @return the new message boards thread
3936            */
3937            public static com.liferay.portlet.messageboards.model.MBThread create(
3938                    long threadId) {
3939                    return getPersistence().create(threadId);
3940            }
3941    
3942            /**
3943            * Removes the message boards thread with the primary key from the database. Also notifies the appropriate model listeners.
3944            *
3945            * @param threadId the primary key of the message boards thread
3946            * @return the message boards thread that was removed
3947            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
3948            * @throws SystemException if a system exception occurred
3949            */
3950            public static com.liferay.portlet.messageboards.model.MBThread remove(
3951                    long threadId)
3952                    throws com.liferay.portal.kernel.exception.SystemException,
3953                            com.liferay.portlet.messageboards.NoSuchThreadException {
3954                    return getPersistence().remove(threadId);
3955            }
3956    
3957            public static com.liferay.portlet.messageboards.model.MBThread updateImpl(
3958                    com.liferay.portlet.messageboards.model.MBThread mbThread)
3959                    throws com.liferay.portal.kernel.exception.SystemException {
3960                    return getPersistence().updateImpl(mbThread);
3961            }
3962    
3963            /**
3964            * Returns the message boards thread with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchThreadException} if it could not be found.
3965            *
3966            * @param threadId the primary key of the message boards thread
3967            * @return the message boards thread
3968            * @throws com.liferay.portlet.messageboards.NoSuchThreadException if a message boards thread with the primary key could not be found
3969            * @throws SystemException if a system exception occurred
3970            */
3971            public static com.liferay.portlet.messageboards.model.MBThread findByPrimaryKey(
3972                    long threadId)
3973                    throws com.liferay.portal.kernel.exception.SystemException,
3974                            com.liferay.portlet.messageboards.NoSuchThreadException {
3975                    return getPersistence().findByPrimaryKey(threadId);
3976            }
3977    
3978            /**
3979            * Returns the message boards thread with the primary key or returns <code>null</code> if it could not be found.
3980            *
3981            * @param threadId the primary key of the message boards thread
3982            * @return the message boards thread, or <code>null</code> if a message boards thread with the primary key could not be found
3983            * @throws SystemException if a system exception occurred
3984            */
3985            public static com.liferay.portlet.messageboards.model.MBThread fetchByPrimaryKey(
3986                    long threadId)
3987                    throws com.liferay.portal.kernel.exception.SystemException {
3988                    return getPersistence().fetchByPrimaryKey(threadId);
3989            }
3990    
3991            /**
3992            * Returns all the message boards threads.
3993            *
3994            * @return the message boards threads
3995            * @throws SystemException if a system exception occurred
3996            */
3997            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll()
3998                    throws com.liferay.portal.kernel.exception.SystemException {
3999                    return getPersistence().findAll();
4000            }
4001    
4002            /**
4003            * Returns a range of all the message boards threads.
4004            *
4005            * <p>
4006            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4007            * </p>
4008            *
4009            * @param start the lower bound of the range of message boards threads
4010            * @param end the upper bound of the range of message boards threads (not inclusive)
4011            * @return the range of message boards threads
4012            * @throws SystemException if a system exception occurred
4013            */
4014            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll(
4015                    int start, int end)
4016                    throws com.liferay.portal.kernel.exception.SystemException {
4017                    return getPersistence().findAll(start, end);
4018            }
4019    
4020            /**
4021            * Returns an ordered range of all the message boards threads.
4022            *
4023            * <p>
4024            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.messageboards.model.impl.MBThreadModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4025            * </p>
4026            *
4027            * @param start the lower bound of the range of message boards threads
4028            * @param end the upper bound of the range of message boards threads (not inclusive)
4029            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4030            * @return the ordered range of message boards threads
4031            * @throws SystemException if a system exception occurred
4032            */
4033            public static java.util.List<com.liferay.portlet.messageboards.model.MBThread> findAll(
4034                    int start, int end,
4035                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4036                    throws com.liferay.portal.kernel.exception.SystemException {
4037                    return getPersistence().findAll(start, end, orderByComparator);
4038            }
4039    
4040            /**
4041            * Removes all the message boards threads from the database.
4042            *
4043            * @throws SystemException if a system exception occurred
4044            */
4045            public static void removeAll()
4046                    throws com.liferay.portal.kernel.exception.SystemException {
4047                    getPersistence().removeAll();
4048            }
4049    
4050            /**
4051            * Returns the number of message boards threads.
4052            *
4053            * @return the number of message boards threads
4054            * @throws SystemException if a system exception occurred
4055            */
4056            public static int countAll()
4057                    throws com.liferay.portal.kernel.exception.SystemException {
4058                    return getPersistence().countAll();
4059            }
4060    
4061            public static MBThreadPersistence getPersistence() {
4062                    if (_persistence == null) {
4063                            _persistence = (MBThreadPersistence)PortalBeanLocatorUtil.locate(MBThreadPersistence.class.getName());
4064    
4065                            ReferenceRegistry.registerReference(MBThreadUtil.class,
4066                                    "_persistence");
4067                    }
4068    
4069                    return _persistence;
4070            }
4071    
4072            /**
4073             * @deprecated As of 6.2.0
4074             */
4075            public void setPersistence(MBThreadPersistence persistence) {
4076            }
4077    
4078            private static MBThreadPersistence _persistence;
4079    }