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