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