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