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