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