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