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