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