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