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