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