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