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