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