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