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