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