001    /**
002     * Copyright (c) 2000-2010 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.service.ServiceContext;
022    
023    import com.liferay.portlet.messageboards.model.MBCategory;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the message boards category service.
029     *
030     * <p>
031     * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class.
032     * </p>
033     *
034     * @author Brian Wing Shun Chan
035     * @see MBCategoryPersistence
036     * @see MBCategoryPersistenceImpl
037     * @generated
038     */
039    public class MBCategoryUtil {
040            /**
041             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
042             */
043            public static void clearCache() {
044                    getPersistence().clearCache();
045            }
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
049             */
050            public static void clearCache(MBCategory mbCategory) {
051                    getPersistence().clearCache(mbCategory);
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
056             */
057            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
058                    throws SystemException {
059                    return getPersistence().countWithDynamicQuery(dynamicQuery);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
064             */
065            public static List<MBCategory> findWithDynamicQuery(
066                    DynamicQuery dynamicQuery) throws SystemException {
067                    return getPersistence().findWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
072             */
073            public static List<MBCategory> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery, int start, int end)
075                    throws SystemException {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
081             */
082            public static List<MBCategory> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end,
084                    OrderByComparator orderByComparator) throws SystemException {
085                    return getPersistence()
086                                       .findWithDynamicQuery(dynamicQuery, start, end,
087                            orderByComparator);
088            }
089    
090            /**
091             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
092             */
093            public static MBCategory remove(MBCategory mbCategory)
094                    throws SystemException {
095                    return getPersistence().remove(mbCategory);
096            }
097    
098            /**
099             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
100             */
101            public static MBCategory update(MBCategory mbCategory, boolean merge)
102                    throws SystemException {
103                    return getPersistence().update(mbCategory, merge);
104            }
105    
106            /**
107             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
108             */
109            public static MBCategory update(MBCategory mbCategory, boolean merge,
110                    ServiceContext serviceContext) throws SystemException {
111                    return getPersistence().update(mbCategory, merge, serviceContext);
112            }
113    
114            /**
115            * Caches the message boards category in the entity cache if it is enabled.
116            *
117            * @param mbCategory the message boards category to cache
118            */
119            public static void cacheResult(
120                    com.liferay.portlet.messageboards.model.MBCategory mbCategory) {
121                    getPersistence().cacheResult(mbCategory);
122            }
123    
124            /**
125            * Caches the message boards categories in the entity cache if it is enabled.
126            *
127            * @param mbCategories the message boards categories to cache
128            */
129            public static void cacheResult(
130                    java.util.List<com.liferay.portlet.messageboards.model.MBCategory> mbCategories) {
131                    getPersistence().cacheResult(mbCategories);
132            }
133    
134            /**
135            * Creates a new message boards category with the primary key.
136            *
137            * @param categoryId the primary key for the new message boards category
138            * @return the new message boards category
139            */
140            public static com.liferay.portlet.messageboards.model.MBCategory create(
141                    long categoryId) {
142                    return getPersistence().create(categoryId);
143            }
144    
145            /**
146            * Removes the message boards category with the primary key from the database. Also notifies the appropriate model listeners.
147            *
148            * @param categoryId the primary key of the message boards category to remove
149            * @return the message boards category that was removed
150            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found
151            * @throws SystemException if a system exception occurred
152            */
153            public static com.liferay.portlet.messageboards.model.MBCategory remove(
154                    long categoryId)
155                    throws com.liferay.portal.kernel.exception.SystemException,
156                            com.liferay.portlet.messageboards.NoSuchCategoryException {
157                    return getPersistence().remove(categoryId);
158            }
159    
160            public static com.liferay.portlet.messageboards.model.MBCategory updateImpl(
161                    com.liferay.portlet.messageboards.model.MBCategory mbCategory,
162                    boolean merge)
163                    throws com.liferay.portal.kernel.exception.SystemException {
164                    return getPersistence().updateImpl(mbCategory, merge);
165            }
166    
167            /**
168            * Finds the message boards category with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchCategoryException} if it could not be found.
169            *
170            * @param categoryId the primary key of the message boards category to find
171            * @return the message boards category
172            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.messageboards.model.MBCategory findByPrimaryKey(
176                    long categoryId)
177                    throws com.liferay.portal.kernel.exception.SystemException,
178                            com.liferay.portlet.messageboards.NoSuchCategoryException {
179                    return getPersistence().findByPrimaryKey(categoryId);
180            }
181    
182            /**
183            * Finds the message boards category with the primary key or returns <code>null</code> if it could not be found.
184            *
185            * @param categoryId the primary key of the message boards category to find
186            * @return the message boards category, or <code>null</code> if a message boards category with the primary key could not be found
187            * @throws SystemException if a system exception occurred
188            */
189            public static com.liferay.portlet.messageboards.model.MBCategory fetchByPrimaryKey(
190                    long categoryId)
191                    throws com.liferay.portal.kernel.exception.SystemException {
192                    return getPersistence().fetchByPrimaryKey(categoryId);
193            }
194    
195            /**
196            * Finds all the message boards categories where uuid = &#63;.
197            *
198            * @param uuid the uuid to search with
199            * @return the matching message boards categories
200            * @throws SystemException if a system exception occurred
201            */
202            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid(
203                    java.lang.String uuid)
204                    throws com.liferay.portal.kernel.exception.SystemException {
205                    return getPersistence().findByUuid(uuid);
206            }
207    
208            /**
209            * Finds a range of all the message boards categories where uuid = &#63;.
210            *
211            * <p>
212            * 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.
213            * </p>
214            *
215            * @param uuid the uuid to search with
216            * @param start the lower bound of the range of message boards categories to return
217            * @param end the upper bound of the range of message boards categories to return (not inclusive)
218            * @return the range of matching message boards categories
219            * @throws SystemException if a system exception occurred
220            */
221            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid(
222                    java.lang.String uuid, int start, int end)
223                    throws com.liferay.portal.kernel.exception.SystemException {
224                    return getPersistence().findByUuid(uuid, start, end);
225            }
226    
227            /**
228            * Finds an ordered range of all the message boards categories where uuid = &#63;.
229            *
230            * <p>
231            * 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.
232            * </p>
233            *
234            * @param uuid the uuid to search with
235            * @param start the lower bound of the range of message boards categories to return
236            * @param end the upper bound of the range of message boards categories to return (not inclusive)
237            * @param orderByComparator the comparator to order the results by
238            * @return the ordered range of matching message boards categories
239            * @throws SystemException if a system exception occurred
240            */
241            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid(
242                    java.lang.String uuid, int start, int end,
243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
244                    throws com.liferay.portal.kernel.exception.SystemException {
245                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
246            }
247    
248            /**
249            * Finds the first message boards category in the ordered set where uuid = &#63;.
250            *
251            * <p>
252            * 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.
253            * </p>
254            *
255            * @param uuid the uuid to search with
256            * @param orderByComparator the comparator to order the set by
257            * @return the first matching message boards category
258            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found
259            * @throws SystemException if a system exception occurred
260            */
261            public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_First(
262                    java.lang.String uuid,
263                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
264                    throws com.liferay.portal.kernel.exception.SystemException,
265                            com.liferay.portlet.messageboards.NoSuchCategoryException {
266                    return getPersistence().findByUuid_First(uuid, orderByComparator);
267            }
268    
269            /**
270            * Finds the last message boards category in the ordered set where uuid = &#63;.
271            *
272            * <p>
273            * 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.
274            * </p>
275            *
276            * @param uuid the uuid to search with
277            * @param orderByComparator the comparator to order the set by
278            * @return the last matching message boards category
279            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found
280            * @throws SystemException if a system exception occurred
281            */
282            public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_Last(
283                    java.lang.String uuid,
284                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
285                    throws com.liferay.portal.kernel.exception.SystemException,
286                            com.liferay.portlet.messageboards.NoSuchCategoryException {
287                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
288            }
289    
290            /**
291            * Finds the message boards categories before and after the current message boards category in the ordered set where uuid = &#63;.
292            *
293            * <p>
294            * 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.
295            * </p>
296            *
297            * @param categoryId the primary key of the current message boards category
298            * @param uuid the uuid to search with
299            * @param orderByComparator the comparator to order the set by
300            * @return the previous, current, and next message boards category
301            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found
302            * @throws SystemException if a system exception occurred
303            */
304            public static com.liferay.portlet.messageboards.model.MBCategory[] findByUuid_PrevAndNext(
305                    long categoryId, java.lang.String uuid,
306                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
307                    throws com.liferay.portal.kernel.exception.SystemException,
308                            com.liferay.portlet.messageboards.NoSuchCategoryException {
309                    return getPersistence()
310                                       .findByUuid_PrevAndNext(categoryId, uuid, orderByComparator);
311            }
312    
313            /**
314            * Finds 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.
315            *
316            * @param uuid the uuid to search with
317            * @param groupId the group id to search with
318            * @return the matching message boards category
319            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found
320            * @throws SystemException if a system exception occurred
321            */
322            public static com.liferay.portlet.messageboards.model.MBCategory findByUUID_G(
323                    java.lang.String uuid, long groupId)
324                    throws com.liferay.portal.kernel.exception.SystemException,
325                            com.liferay.portlet.messageboards.NoSuchCategoryException {
326                    return getPersistence().findByUUID_G(uuid, groupId);
327            }
328    
329            /**
330            * Finds 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.
331            *
332            * @param uuid the uuid to search with
333            * @param groupId the group id to search with
334            * @return the matching message boards category, or <code>null</code> if a matching message boards category could not be found
335            * @throws SystemException if a system exception occurred
336            */
337            public static com.liferay.portlet.messageboards.model.MBCategory fetchByUUID_G(
338                    java.lang.String uuid, long groupId)
339                    throws com.liferay.portal.kernel.exception.SystemException {
340                    return getPersistence().fetchByUUID_G(uuid, groupId);
341            }
342    
343            /**
344            * Finds 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.
345            *
346            * @param uuid the uuid to search with
347            * @param groupId the group id to search with
348            * @return the matching message boards category, or <code>null</code> if a matching message boards category could not be found
349            * @throws SystemException if a system exception occurred
350            */
351            public static com.liferay.portlet.messageboards.model.MBCategory fetchByUUID_G(
352                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
353                    throws com.liferay.portal.kernel.exception.SystemException {
354                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
355            }
356    
357            /**
358            * Finds all the message boards categories where groupId = &#63;.
359            *
360            * @param groupId the group id to search with
361            * @return the matching message boards categories
362            * @throws SystemException if a system exception occurred
363            */
364            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId(
365                    long groupId)
366                    throws com.liferay.portal.kernel.exception.SystemException {
367                    return getPersistence().findByGroupId(groupId);
368            }
369    
370            /**
371            * Finds a range of all the message boards categories where groupId = &#63;.
372            *
373            * <p>
374            * 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.
375            * </p>
376            *
377            * @param groupId the group id to search with
378            * @param start the lower bound of the range of message boards categories to return
379            * @param end the upper bound of the range of message boards categories to return (not inclusive)
380            * @return the range of matching message boards categories
381            * @throws SystemException if a system exception occurred
382            */
383            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId(
384                    long groupId, int start, int end)
385                    throws com.liferay.portal.kernel.exception.SystemException {
386                    return getPersistence().findByGroupId(groupId, start, end);
387            }
388    
389            /**
390            * Finds an ordered range of all the message boards categories where groupId = &#63;.
391            *
392            * <p>
393            * 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.
394            * </p>
395            *
396            * @param groupId the group id to search with
397            * @param start the lower bound of the range of message boards categories to return
398            * @param end the upper bound of the range of message boards categories to return (not inclusive)
399            * @param orderByComparator the comparator to order the results by
400            * @return the ordered range of matching message boards categories
401            * @throws SystemException if a system exception occurred
402            */
403            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId(
404                    long groupId, int start, int end,
405                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
406                    throws com.liferay.portal.kernel.exception.SystemException {
407                    return getPersistence()
408                                       .findByGroupId(groupId, start, end, orderByComparator);
409            }
410    
411            /**
412            * Finds the first message boards category in the ordered set where groupId = &#63;.
413            *
414            * <p>
415            * 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.
416            * </p>
417            *
418            * @param groupId the group id to search with
419            * @param orderByComparator the comparator to order the set by
420            * @return the first matching message boards category
421            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found
422            * @throws SystemException if a system exception occurred
423            */
424            public static com.liferay.portlet.messageboards.model.MBCategory findByGroupId_First(
425                    long groupId,
426                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
427                    throws com.liferay.portal.kernel.exception.SystemException,
428                            com.liferay.portlet.messageboards.NoSuchCategoryException {
429                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
430            }
431    
432            /**
433            * Finds the last message boards category in the ordered set where groupId = &#63;.
434            *
435            * <p>
436            * 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.
437            * </p>
438            *
439            * @param groupId the group id to search with
440            * @param orderByComparator the comparator to order the set by
441            * @return the last matching message boards category
442            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found
443            * @throws SystemException if a system exception occurred
444            */
445            public static com.liferay.portlet.messageboards.model.MBCategory findByGroupId_Last(
446                    long groupId,
447                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
448                    throws com.liferay.portal.kernel.exception.SystemException,
449                            com.liferay.portlet.messageboards.NoSuchCategoryException {
450                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
451            }
452    
453            /**
454            * Finds the message boards categories before and after the current message boards category in the ordered set where groupId = &#63;.
455            *
456            * <p>
457            * 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.
458            * </p>
459            *
460            * @param categoryId the primary key of the current message boards category
461            * @param groupId the group id to search with
462            * @param orderByComparator the comparator to order the set by
463            * @return the previous, current, and next message boards category
464            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found
465            * @throws SystemException if a system exception occurred
466            */
467            public static com.liferay.portlet.messageboards.model.MBCategory[] findByGroupId_PrevAndNext(
468                    long categoryId, long groupId,
469                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
470                    throws com.liferay.portal.kernel.exception.SystemException,
471                            com.liferay.portlet.messageboards.NoSuchCategoryException {
472                    return getPersistence()
473                                       .findByGroupId_PrevAndNext(categoryId, groupId,
474                            orderByComparator);
475            }
476    
477            /**
478            * Filters by the user's permissions and finds all the message boards categories where groupId = &#63;.
479            *
480            * @param groupId the group id to search with
481            * @return the matching message boards categories that the user has permission to view
482            * @throws SystemException if a system exception occurred
483            */
484            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId(
485                    long groupId)
486                    throws com.liferay.portal.kernel.exception.SystemException {
487                    return getPersistence().filterFindByGroupId(groupId);
488            }
489    
490            /**
491            * Filters by the user's permissions and finds a range of all the message boards categories where groupId = &#63;.
492            *
493            * <p>
494            * 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.
495            * </p>
496            *
497            * @param groupId the group id to search with
498            * @param start the lower bound of the range of message boards categories to return
499            * @param end the upper bound of the range of message boards categories to return (not inclusive)
500            * @return the range of matching message boards categories that the user has permission to view
501            * @throws SystemException if a system exception occurred
502            */
503            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId(
504                    long groupId, int start, int end)
505                    throws com.liferay.portal.kernel.exception.SystemException {
506                    return getPersistence().filterFindByGroupId(groupId, start, end);
507            }
508    
509            /**
510            * Filters by the user's permissions and finds an ordered range of all the message boards categories where groupId = &#63;.
511            *
512            * <p>
513            * 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.
514            * </p>
515            *
516            * @param groupId the group id to search with
517            * @param start the lower bound of the range of message boards categories to return
518            * @param end the upper bound of the range of message boards categories to return (not inclusive)
519            * @param orderByComparator the comparator to order the results by
520            * @return the ordered range of matching message boards categories that the user has permission to view
521            * @throws SystemException if a system exception occurred
522            */
523            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId(
524                    long groupId, int start, int end,
525                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
526                    throws com.liferay.portal.kernel.exception.SystemException {
527                    return getPersistence()
528                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
529            }
530    
531            /**
532            * Finds all the message boards categories where companyId = &#63;.
533            *
534            * @param companyId the company id to search with
535            * @return the matching message boards categories
536            * @throws SystemException if a system exception occurred
537            */
538            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId(
539                    long companyId)
540                    throws com.liferay.portal.kernel.exception.SystemException {
541                    return getPersistence().findByCompanyId(companyId);
542            }
543    
544            /**
545            * Finds a range of all the message boards categories where companyId = &#63;.
546            *
547            * <p>
548            * 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.
549            * </p>
550            *
551            * @param companyId the company id to search with
552            * @param start the lower bound of the range of message boards categories to return
553            * @param end the upper bound of the range of message boards categories to return (not inclusive)
554            * @return the range of matching message boards categories
555            * @throws SystemException if a system exception occurred
556            */
557            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId(
558                    long companyId, int start, int end)
559                    throws com.liferay.portal.kernel.exception.SystemException {
560                    return getPersistence().findByCompanyId(companyId, start, end);
561            }
562    
563            /**
564            * Finds an ordered range of all the message boards categories where companyId = &#63;.
565            *
566            * <p>
567            * 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.
568            * </p>
569            *
570            * @param companyId the company id to search with
571            * @param start the lower bound of the range of message boards categories to return
572            * @param end the upper bound of the range of message boards categories to return (not inclusive)
573            * @param orderByComparator the comparator to order the results by
574            * @return the ordered range of matching message boards categories
575            * @throws SystemException if a system exception occurred
576            */
577            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId(
578                    long companyId, int start, int end,
579                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
580                    throws com.liferay.portal.kernel.exception.SystemException {
581                    return getPersistence()
582                                       .findByCompanyId(companyId, start, end, orderByComparator);
583            }
584    
585            /**
586            * Finds the first message boards category in the ordered set where companyId = &#63;.
587            *
588            * <p>
589            * 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.
590            * </p>
591            *
592            * @param companyId the company id to search with
593            * @param orderByComparator the comparator to order the set by
594            * @return the first matching message boards category
595            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found
596            * @throws SystemException if a system exception occurred
597            */
598            public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_First(
599                    long companyId,
600                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
601                    throws com.liferay.portal.kernel.exception.SystemException,
602                            com.liferay.portlet.messageboards.NoSuchCategoryException {
603                    return getPersistence()
604                                       .findByCompanyId_First(companyId, orderByComparator);
605            }
606    
607            /**
608            * Finds the last message boards category in the ordered set where companyId = &#63;.
609            *
610            * <p>
611            * 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.
612            * </p>
613            *
614            * @param companyId the company id to search with
615            * @param orderByComparator the comparator to order the set by
616            * @return the last matching message boards category
617            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found
618            * @throws SystemException if a system exception occurred
619            */
620            public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_Last(
621                    long companyId,
622                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
623                    throws com.liferay.portal.kernel.exception.SystemException,
624                            com.liferay.portlet.messageboards.NoSuchCategoryException {
625                    return getPersistence()
626                                       .findByCompanyId_Last(companyId, orderByComparator);
627            }
628    
629            /**
630            * Finds the message boards categories before and after the current message boards category in the ordered set where companyId = &#63;.
631            *
632            * <p>
633            * 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.
634            * </p>
635            *
636            * @param categoryId the primary key of the current message boards category
637            * @param companyId the company id to search with
638            * @param orderByComparator the comparator to order the set by
639            * @return the previous, current, and next message boards category
640            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found
641            * @throws SystemException if a system exception occurred
642            */
643            public static com.liferay.portlet.messageboards.model.MBCategory[] findByCompanyId_PrevAndNext(
644                    long categoryId, long companyId,
645                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
646                    throws com.liferay.portal.kernel.exception.SystemException,
647                            com.liferay.portlet.messageboards.NoSuchCategoryException {
648                    return getPersistence()
649                                       .findByCompanyId_PrevAndNext(categoryId, companyId,
650                            orderByComparator);
651            }
652    
653            /**
654            * Finds all the message boards categories where groupId = &#63; and parentCategoryId = &#63;.
655            *
656            * @param groupId the group id to search with
657            * @param parentCategoryId the parent category id to search with
658            * @return the matching message boards categories
659            * @throws SystemException if a system exception occurred
660            */
661            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P(
662                    long groupId, long parentCategoryId)
663                    throws com.liferay.portal.kernel.exception.SystemException {
664                    return getPersistence().findByG_P(groupId, parentCategoryId);
665            }
666    
667            /**
668            * Finds a range of all the message boards categories where groupId = &#63; and parentCategoryId = &#63;.
669            *
670            * <p>
671            * 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.
672            * </p>
673            *
674            * @param groupId the group id to search with
675            * @param parentCategoryId the parent category id to search with
676            * @param start the lower bound of the range of message boards categories to return
677            * @param end the upper bound of the range of message boards categories to return (not inclusive)
678            * @return the range of matching message boards categories
679            * @throws SystemException if a system exception occurred
680            */
681            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P(
682                    long groupId, long parentCategoryId, int start, int end)
683                    throws com.liferay.portal.kernel.exception.SystemException {
684                    return getPersistence().findByG_P(groupId, parentCategoryId, start, end);
685            }
686    
687            /**
688            * Finds an ordered range of all the message boards categories where groupId = &#63; and parentCategoryId = &#63;.
689            *
690            * <p>
691            * 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.
692            * </p>
693            *
694            * @param groupId the group id to search with
695            * @param parentCategoryId the parent category id to search with
696            * @param start the lower bound of the range of message boards categories to return
697            * @param end the upper bound of the range of message boards categories to return (not inclusive)
698            * @param orderByComparator the comparator to order the results by
699            * @return the ordered range of matching message boards categories
700            * @throws SystemException if a system exception occurred
701            */
702            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P(
703                    long groupId, long parentCategoryId, int start, int end,
704                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
705                    throws com.liferay.portal.kernel.exception.SystemException {
706                    return getPersistence()
707                                       .findByG_P(groupId, parentCategoryId, start, end,
708                            orderByComparator);
709            }
710    
711            /**
712            * Finds the first message boards category in the ordered set where groupId = &#63; and parentCategoryId = &#63;.
713            *
714            * <p>
715            * 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.
716            * </p>
717            *
718            * @param groupId the group id to search with
719            * @param parentCategoryId the parent category id to search with
720            * @param orderByComparator the comparator to order the set by
721            * @return the first matching message boards category
722            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found
723            * @throws SystemException if a system exception occurred
724            */
725            public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_First(
726                    long groupId, long parentCategoryId,
727                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
728                    throws com.liferay.portal.kernel.exception.SystemException,
729                            com.liferay.portlet.messageboards.NoSuchCategoryException {
730                    return getPersistence()
731                                       .findByG_P_First(groupId, parentCategoryId, orderByComparator);
732            }
733    
734            /**
735            * Finds the last message boards category in the ordered set where groupId = &#63; and parentCategoryId = &#63;.
736            *
737            * <p>
738            * 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.
739            * </p>
740            *
741            * @param groupId the group id to search with
742            * @param parentCategoryId the parent category id to search with
743            * @param orderByComparator the comparator to order the set by
744            * @return the last matching message boards category
745            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found
746            * @throws SystemException if a system exception occurred
747            */
748            public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_Last(
749                    long groupId, long parentCategoryId,
750                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
751                    throws com.liferay.portal.kernel.exception.SystemException,
752                            com.liferay.portlet.messageboards.NoSuchCategoryException {
753                    return getPersistence()
754                                       .findByG_P_Last(groupId, parentCategoryId, orderByComparator);
755            }
756    
757            /**
758            * Finds the message boards categories before and after the current message boards category in the ordered set where groupId = &#63; and parentCategoryId = &#63;.
759            *
760            * <p>
761            * 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.
762            * </p>
763            *
764            * @param categoryId the primary key of the current message boards category
765            * @param groupId the group id to search with
766            * @param parentCategoryId the parent category id to search with
767            * @param orderByComparator the comparator to order the set by
768            * @return the previous, current, and next message boards category
769            * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found
770            * @throws SystemException if a system exception occurred
771            */
772            public static com.liferay.portlet.messageboards.model.MBCategory[] findByG_P_PrevAndNext(
773                    long categoryId, long groupId, long parentCategoryId,
774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
775                    throws com.liferay.portal.kernel.exception.SystemException,
776                            com.liferay.portlet.messageboards.NoSuchCategoryException {
777                    return getPersistence()
778                                       .findByG_P_PrevAndNext(categoryId, groupId,
779                            parentCategoryId, orderByComparator);
780            }
781    
782            /**
783            * Finds all the message boards categories where groupId = &#63; and parentCategoryId = any &#63;.
784            *
785            * <p>
786            * 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.
787            * </p>
788            *
789            * @param groupId the group id to search with
790            * @param parentCategoryIds the parent category ids to search with
791            * @return the matching message boards categories
792            * @throws SystemException if a system exception occurred
793            */
794            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P(
795                    long groupId, long[] parentCategoryIds)
796                    throws com.liferay.portal.kernel.exception.SystemException {
797                    return getPersistence().findByG_P(groupId, parentCategoryIds);
798            }
799    
800            /**
801            * Finds a range of all the message boards categories where groupId = &#63; and parentCategoryId = any &#63;.
802            *
803            * <p>
804            * 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.
805            * </p>
806            *
807            * @param groupId the group id to search with
808            * @param parentCategoryIds the parent category ids to search with
809            * @param start the lower bound of the range of message boards categories to return
810            * @param end the upper bound of the range of message boards categories to return (not inclusive)
811            * @return the range of matching message boards categories
812            * @throws SystemException if a system exception occurred
813            */
814            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P(
815                    long groupId, long[] parentCategoryIds, int start, int end)
816                    throws com.liferay.portal.kernel.exception.SystemException {
817                    return getPersistence().findByG_P(groupId, parentCategoryIds, start, end);
818            }
819    
820            /**
821            * Finds an ordered range of all the message boards categories where groupId = &#63; and parentCategoryId = any &#63;.
822            *
823            * <p>
824            * 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.
825            * </p>
826            *
827            * @param groupId the group id to search with
828            * @param parentCategoryIds the parent category ids to search with
829            * @param start the lower bound of the range of message boards categories to return
830            * @param end the upper bound of the range of message boards categories to return (not inclusive)
831            * @param orderByComparator the comparator to order the results by
832            * @return the ordered range of matching message boards categories
833            * @throws SystemException if a system exception occurred
834            */
835            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P(
836                    long groupId, long[] parentCategoryIds, int start, int end,
837                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
838                    throws com.liferay.portal.kernel.exception.SystemException {
839                    return getPersistence()
840                                       .findByG_P(groupId, parentCategoryIds, start, end,
841                            orderByComparator);
842            }
843    
844            /**
845            * Filters by the user's permissions and finds all the message boards categories where groupId = &#63; and parentCategoryId = &#63;.
846            *
847            * @param groupId the group id to search with
848            * @param parentCategoryId the parent category id to search with
849            * @return the matching message boards categories that the user has permission to view
850            * @throws SystemException if a system exception occurred
851            */
852            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P(
853                    long groupId, long parentCategoryId)
854                    throws com.liferay.portal.kernel.exception.SystemException {
855                    return getPersistence().filterFindByG_P(groupId, parentCategoryId);
856            }
857    
858            /**
859            * Filters by the user's permissions and finds a range of all the message boards categories where groupId = &#63; and parentCategoryId = &#63;.
860            *
861            * <p>
862            * 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.
863            * </p>
864            *
865            * @param groupId the group id to search with
866            * @param parentCategoryId the parent category id to search with
867            * @param start the lower bound of the range of message boards categories to return
868            * @param end the upper bound of the range of message boards categories to return (not inclusive)
869            * @return the range of matching message boards categories that the user has permission to view
870            * @throws SystemException if a system exception occurred
871            */
872            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P(
873                    long groupId, long parentCategoryId, int start, int end)
874                    throws com.liferay.portal.kernel.exception.SystemException {
875                    return getPersistence()
876                                       .filterFindByG_P(groupId, parentCategoryId, start, end);
877            }
878    
879            /**
880            * Filters by the user's permissions and finds an ordered range of all the message boards categories where groupId = &#63; and parentCategoryId = &#63;.
881            *
882            * <p>
883            * 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.
884            * </p>
885            *
886            * @param groupId the group id to search with
887            * @param parentCategoryId the parent category id to search with
888            * @param start the lower bound of the range of message boards categories to return
889            * @param end the upper bound of the range of message boards categories to return (not inclusive)
890            * @param orderByComparator the comparator to order the results by
891            * @return the ordered range of matching message boards categories that the user has permission to view
892            * @throws SystemException if a system exception occurred
893            */
894            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P(
895                    long groupId, long parentCategoryId, int start, int end,
896                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
897                    throws com.liferay.portal.kernel.exception.SystemException {
898                    return getPersistence()
899                                       .filterFindByG_P(groupId, parentCategoryId, start, end,
900                            orderByComparator);
901            }
902    
903            /**
904            * Filters by the user's permissions and finds all the message boards categories where groupId = &#63; and parentCategoryId = any &#63;.
905            *
906            * <p>
907            * 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.
908            * </p>
909            *
910            * @param groupId the group id to search with
911            * @param parentCategoryIds the parent category ids to search with
912            * @return the matching message boards categories that the user has permission to view
913            * @throws SystemException if a system exception occurred
914            */
915            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P(
916                    long groupId, long[] parentCategoryIds)
917                    throws com.liferay.portal.kernel.exception.SystemException {
918                    return getPersistence().filterFindByG_P(groupId, parentCategoryIds);
919            }
920    
921            /**
922            * Filters by the user's permissions and finds a range of all the message boards categories where groupId = &#63; and parentCategoryId = any &#63;.
923            *
924            * <p>
925            * 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.
926            * </p>
927            *
928            * @param groupId the group id to search with
929            * @param parentCategoryIds the parent category ids to search with
930            * @param start the lower bound of the range of message boards categories to return
931            * @param end the upper bound of the range of message boards categories to return (not inclusive)
932            * @return the range of matching message boards categories that the user has permission to view
933            * @throws SystemException if a system exception occurred
934            */
935            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P(
936                    long groupId, long[] parentCategoryIds, int start, int end)
937                    throws com.liferay.portal.kernel.exception.SystemException {
938                    return getPersistence()
939                                       .filterFindByG_P(groupId, parentCategoryIds, start, end);
940            }
941    
942            /**
943            * Filters by the user's permissions and finds an ordered range of all the message boards categories where groupId = &#63; and parentCategoryId = any &#63;.
944            *
945            * <p>
946            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
947            * </p>
948            *
949            * @param groupId the group id to search with
950            * @param parentCategoryIds the parent category ids to search with
951            * @param start the lower bound of the range of message boards categories to return
952            * @param end the upper bound of the range of message boards categories to return (not inclusive)
953            * @param orderByComparator the comparator to order the results by
954            * @return the ordered range of matching message boards categories that the user has permission to view
955            * @throws SystemException if a system exception occurred
956            */
957            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P(
958                    long groupId, long[] parentCategoryIds, int start, int end,
959                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
960                    throws com.liferay.portal.kernel.exception.SystemException {
961                    return getPersistence()
962                                       .filterFindByG_P(groupId, parentCategoryIds, start, end,
963                            orderByComparator);
964            }
965    
966            /**
967            * Finds all the message boards categories.
968            *
969            * @return the message boards categories
970            * @throws SystemException if a system exception occurred
971            */
972            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll()
973                    throws com.liferay.portal.kernel.exception.SystemException {
974                    return getPersistence().findAll();
975            }
976    
977            /**
978            * Finds a range of all the message boards categories.
979            *
980            * <p>
981            * 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.
982            * </p>
983            *
984            * @param start the lower bound of the range of message boards categories to return
985            * @param end the upper bound of the range of message boards categories to return (not inclusive)
986            * @return the range of message boards categories
987            * @throws SystemException if a system exception occurred
988            */
989            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll(
990                    int start, int end)
991                    throws com.liferay.portal.kernel.exception.SystemException {
992                    return getPersistence().findAll(start, end);
993            }
994    
995            /**
996            * Finds an ordered range of all the message boards categories.
997            *
998            * <p>
999            * 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.
1000            * </p>
1001            *
1002            * @param start the lower bound of the range of message boards categories to return
1003            * @param end the upper bound of the range of message boards categories to return (not inclusive)
1004            * @param orderByComparator the comparator to order the results by
1005            * @return the ordered range of message boards categories
1006            * @throws SystemException if a system exception occurred
1007            */
1008            public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll(
1009                    int start, int end,
1010                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1011                    throws com.liferay.portal.kernel.exception.SystemException {
1012                    return getPersistence().findAll(start, end, orderByComparator);
1013            }
1014    
1015            /**
1016            * Removes all the message boards categories where uuid = &#63; from the database.
1017            *
1018            * @param uuid the uuid to search with
1019            * @throws SystemException if a system exception occurred
1020            */
1021            public static void removeByUuid(java.lang.String uuid)
1022                    throws com.liferay.portal.kernel.exception.SystemException {
1023                    getPersistence().removeByUuid(uuid);
1024            }
1025    
1026            /**
1027            * Removes the message boards category where uuid = &#63; and groupId = &#63; from the database.
1028            *
1029            * @param uuid the uuid to search with
1030            * @param groupId the group id to search with
1031            * @throws SystemException if a system exception occurred
1032            */
1033            public static void removeByUUID_G(java.lang.String uuid, long groupId)
1034                    throws com.liferay.portal.kernel.exception.SystemException,
1035                            com.liferay.portlet.messageboards.NoSuchCategoryException {
1036                    getPersistence().removeByUUID_G(uuid, groupId);
1037            }
1038    
1039            /**
1040            * Removes all the message boards categories where groupId = &#63; from the database.
1041            *
1042            * @param groupId the group id to search with
1043            * @throws SystemException if a system exception occurred
1044            */
1045            public static void removeByGroupId(long groupId)
1046                    throws com.liferay.portal.kernel.exception.SystemException {
1047                    getPersistence().removeByGroupId(groupId);
1048            }
1049    
1050            /**
1051            * Removes all the message boards categories where companyId = &#63; from the database.
1052            *
1053            * @param companyId the company id to search with
1054            * @throws SystemException if a system exception occurred
1055            */
1056            public static void removeByCompanyId(long companyId)
1057                    throws com.liferay.portal.kernel.exception.SystemException {
1058                    getPersistence().removeByCompanyId(companyId);
1059            }
1060    
1061            /**
1062            * Removes all the message boards categories where groupId = &#63; and parentCategoryId = &#63; from the database.
1063            *
1064            * @param groupId the group id to search with
1065            * @param parentCategoryId the parent category id to search with
1066            * @throws SystemException if a system exception occurred
1067            */
1068            public static void removeByG_P(long groupId, long parentCategoryId)
1069                    throws com.liferay.portal.kernel.exception.SystemException {
1070                    getPersistence().removeByG_P(groupId, parentCategoryId);
1071            }
1072    
1073            /**
1074            * Removes all the message boards categories from the database.
1075            *
1076            * @throws SystemException if a system exception occurred
1077            */
1078            public static void removeAll()
1079                    throws com.liferay.portal.kernel.exception.SystemException {
1080                    getPersistence().removeAll();
1081            }
1082    
1083            /**
1084            * Counts all the message boards categories where uuid = &#63;.
1085            *
1086            * @param uuid the uuid to search with
1087            * @return the number of matching message boards categories
1088            * @throws SystemException if a system exception occurred
1089            */
1090            public static int countByUuid(java.lang.String uuid)
1091                    throws com.liferay.portal.kernel.exception.SystemException {
1092                    return getPersistence().countByUuid(uuid);
1093            }
1094    
1095            /**
1096            * Counts all the message boards categories where uuid = &#63; and groupId = &#63;.
1097            *
1098            * @param uuid the uuid to search with
1099            * @param groupId the group id to search with
1100            * @return the number of matching message boards categories
1101            * @throws SystemException if a system exception occurred
1102            */
1103            public static int countByUUID_G(java.lang.String uuid, long groupId)
1104                    throws com.liferay.portal.kernel.exception.SystemException {
1105                    return getPersistence().countByUUID_G(uuid, groupId);
1106            }
1107    
1108            /**
1109            * Counts all the message boards categories where groupId = &#63;.
1110            *
1111            * @param groupId the group id to search with
1112            * @return the number of matching message boards categories
1113            * @throws SystemException if a system exception occurred
1114            */
1115            public static int countByGroupId(long groupId)
1116                    throws com.liferay.portal.kernel.exception.SystemException {
1117                    return getPersistence().countByGroupId(groupId);
1118            }
1119    
1120            /**
1121            * Filters by the user's permissions and counts all the message boards categories where groupId = &#63;.
1122            *
1123            * @param groupId the group id to search with
1124            * @return the number of matching message boards categories that the user has permission to view
1125            * @throws SystemException if a system exception occurred
1126            */
1127            public static int filterCountByGroupId(long groupId)
1128                    throws com.liferay.portal.kernel.exception.SystemException {
1129                    return getPersistence().filterCountByGroupId(groupId);
1130            }
1131    
1132            /**
1133            * Counts all the message boards categories where companyId = &#63;.
1134            *
1135            * @param companyId the company id to search with
1136            * @return the number of matching message boards categories
1137            * @throws SystemException if a system exception occurred
1138            */
1139            public static int countByCompanyId(long companyId)
1140                    throws com.liferay.portal.kernel.exception.SystemException {
1141                    return getPersistence().countByCompanyId(companyId);
1142            }
1143    
1144            /**
1145            * Counts all the message boards categories where groupId = &#63; and parentCategoryId = &#63;.
1146            *
1147            * @param groupId the group id to search with
1148            * @param parentCategoryId the parent category id to search with
1149            * @return the number of matching message boards categories
1150            * @throws SystemException if a system exception occurred
1151            */
1152            public static int countByG_P(long groupId, long parentCategoryId)
1153                    throws com.liferay.portal.kernel.exception.SystemException {
1154                    return getPersistence().countByG_P(groupId, parentCategoryId);
1155            }
1156    
1157            /**
1158            * Counts all the message boards categories where groupId = &#63; and parentCategoryId = any &#63;.
1159            *
1160            * @param groupId the group id to search with
1161            * @param parentCategoryIds the parent category ids to search with
1162            * @return the number of matching message boards categories
1163            * @throws SystemException if a system exception occurred
1164            */
1165            public static int countByG_P(long groupId, long[] parentCategoryIds)
1166                    throws com.liferay.portal.kernel.exception.SystemException {
1167                    return getPersistence().countByG_P(groupId, parentCategoryIds);
1168            }
1169    
1170            /**
1171            * Filters by the user's permissions and counts all the message boards categories where groupId = &#63; and parentCategoryId = &#63;.
1172            *
1173            * @param groupId the group id to search with
1174            * @param parentCategoryId the parent category id to search with
1175            * @return the number of matching message boards categories that the user has permission to view
1176            * @throws SystemException if a system exception occurred
1177            */
1178            public static int filterCountByG_P(long groupId, long parentCategoryId)
1179                    throws com.liferay.portal.kernel.exception.SystemException {
1180                    return getPersistence().filterCountByG_P(groupId, parentCategoryId);
1181            }
1182    
1183            /**
1184            * Filters by the user's permissions and counts all the message boards categories where groupId = &#63; and parentCategoryId = any &#63;.
1185            *
1186            * @param groupId the group id to search with
1187            * @param parentCategoryIds the parent category ids to search with
1188            * @return the number of matching message boards categories that the user has permission to view
1189            * @throws SystemException if a system exception occurred
1190            */
1191            public static int filterCountByG_P(long groupId, long[] parentCategoryIds)
1192                    throws com.liferay.portal.kernel.exception.SystemException {
1193                    return getPersistence().filterCountByG_P(groupId, parentCategoryIds);
1194            }
1195    
1196            /**
1197            * Counts all the message boards categories.
1198            *
1199            * @return the number of message boards categories
1200            * @throws SystemException if a system exception occurred
1201            */
1202            public static int countAll()
1203                    throws com.liferay.portal.kernel.exception.SystemException {
1204                    return getPersistence().countAll();
1205            }
1206    
1207            public static MBCategoryPersistence getPersistence() {
1208                    if (_persistence == null) {
1209                            _persistence = (MBCategoryPersistence)PortalBeanLocatorUtil.locate(MBCategoryPersistence.class.getName());
1210                    }
1211    
1212                    return _persistence;
1213            }
1214    
1215            public void setPersistence(MBCategoryPersistence persistence) {
1216                    _persistence = persistence;
1217            }
1218    
1219            private static MBCategoryPersistence _persistence;
1220    }