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