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