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