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.asset.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.asset.model.AssetCategory;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the asset category service. This utility wraps {@link AssetCategoryPersistenceImpl} 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 AssetCategoryPersistence
037     * @see AssetCategoryPersistenceImpl
038     * @generated
039     */
040    public class AssetCategoryUtil {
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(AssetCategory assetCategory) {
058                    getPersistence().clearCache(assetCategory);
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<AssetCategory> 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<AssetCategory> 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<AssetCategory> 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 AssetCategory update(AssetCategory assetCategory)
101                    throws SystemException {
102                    return getPersistence().update(assetCategory);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static AssetCategory update(AssetCategory assetCategory,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(assetCategory, serviceContext);
111            }
112    
113            /**
114            * Returns all the asset categories where uuid = &#63;.
115            *
116            * @param uuid the uuid
117            * @return the matching asset categories
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> 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 asset 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.asset.model.impl.AssetCategoryModelImpl}. 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 asset categories
135            * @param end the upper bound of the range of asset categories (not inclusive)
136            * @return the range of matching asset categories
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> 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 asset 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.asset.model.impl.AssetCategoryModelImpl}. 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 asset categories
154            * @param end the upper bound of the range of asset categories (not inclusive)
155            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
156            * @return the ordered range of matching asset categories
157            * @throws SystemException if a system exception occurred
158            */
159            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> 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 asset 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 asset category
172            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.asset.model.AssetCategory 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.asset.NoSuchCategoryException {
180                    return getPersistence().findByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the first asset 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 asset category, or <code>null</code> if a matching asset category could not be found
189            * @throws SystemException if a system exception occurred
190            */
191            public static com.liferay.portlet.asset.model.AssetCategory 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 asset 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 asset category
204            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
205            * @throws SystemException if a system exception occurred
206            */
207            public static com.liferay.portlet.asset.model.AssetCategory 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.asset.NoSuchCategoryException {
212                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the last asset 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 asset category, or <code>null</code> if a matching asset category could not be found
221            * @throws SystemException if a system exception occurred
222            */
223            public static com.liferay.portlet.asset.model.AssetCategory 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 asset categories before and after the current asset category in the ordered set where uuid = &#63;.
232            *
233            * @param categoryId the primary key of the current asset 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 asset category
237            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
238            * @throws SystemException if a system exception occurred
239            */
240            public static com.liferay.portlet.asset.model.AssetCategory[] 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.asset.NoSuchCategoryException {
245                    return getPersistence()
246                                       .findByUuid_PrevAndNext(categoryId, uuid, orderByComparator);
247            }
248    
249            /**
250            * Removes all the asset 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 asset categories where uuid = &#63;.
262            *
263            * @param uuid the uuid
264            * @return the number of matching asset 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 asset category where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.asset.NoSuchCategoryException} if it could not be found.
274            *
275            * @param uuid the uuid
276            * @param groupId the group ID
277            * @return the matching asset category
278            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
279            * @throws SystemException if a system exception occurred
280            */
281            public static com.liferay.portlet.asset.model.AssetCategory findByUUID_G(
282                    java.lang.String uuid, long groupId)
283                    throws com.liferay.portal.kernel.exception.SystemException,
284                            com.liferay.portlet.asset.NoSuchCategoryException {
285                    return getPersistence().findByUUID_G(uuid, groupId);
286            }
287    
288            /**
289            * Returns the asset 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 asset category, or <code>null</code> if a matching asset category could not be found
294            * @throws SystemException if a system exception occurred
295            */
296            public static com.liferay.portlet.asset.model.AssetCategory 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 asset 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 asset category, or <code>null</code> if a matching asset category could not be found
309            * @throws SystemException if a system exception occurred
310            */
311            public static com.liferay.portlet.asset.model.AssetCategory 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 asset 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 asset category that was removed
323            * @throws SystemException if a system exception occurred
324            */
325            public static com.liferay.portlet.asset.model.AssetCategory removeByUUID_G(
326                    java.lang.String uuid, long groupId)
327                    throws com.liferay.portal.kernel.exception.SystemException,
328                            com.liferay.portlet.asset.NoSuchCategoryException {
329                    return getPersistence().removeByUUID_G(uuid, groupId);
330            }
331    
332            /**
333            * Returns the number of asset 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 asset 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 asset categories where uuid = &#63; and companyId = &#63;.
347            *
348            * @param uuid the uuid
349            * @param companyId the company ID
350            * @return the matching asset categories
351            * @throws SystemException if a system exception occurred
352            */
353            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> 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 asset 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.asset.model.impl.AssetCategoryModelImpl}. 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 asset categories
369            * @param end the upper bound of the range of asset categories (not inclusive)
370            * @return the range of matching asset categories
371            * @throws SystemException if a system exception occurred
372            */
373            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> 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 asset 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.asset.model.impl.AssetCategoryModelImpl}. 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 asset categories
389            * @param end the upper bound of the range of asset categories (not inclusive)
390            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
391            * @return the ordered range of matching asset categories
392            * @throws SystemException if a system exception occurred
393            */
394            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> 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 asset 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 asset category
409            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
410            * @throws SystemException if a system exception occurred
411            */
412            public static com.liferay.portlet.asset.model.AssetCategory 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.asset.NoSuchCategoryException {
417                    return getPersistence()
418                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
419            }
420    
421            /**
422            * Returns the first asset 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 asset category, or <code>null</code> if a matching asset category could not be found
428            * @throws SystemException if a system exception occurred
429            */
430            public static com.liferay.portlet.asset.model.AssetCategory 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 asset 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 asset category
445            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
446            * @throws SystemException if a system exception occurred
447            */
448            public static com.liferay.portlet.asset.model.AssetCategory 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.asset.NoSuchCategoryException {
453                    return getPersistence()
454                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
455            }
456    
457            /**
458            * Returns the last asset 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 asset category, or <code>null</code> if a matching asset category could not be found
464            * @throws SystemException if a system exception occurred
465            */
466            public static com.liferay.portlet.asset.model.AssetCategory 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 asset categories before and after the current asset category in the ordered set where uuid = &#63; and companyId = &#63;.
476            *
477            * @param categoryId the primary key of the current asset 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 asset category
482            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
483            * @throws SystemException if a system exception occurred
484            */
485            public static com.liferay.portlet.asset.model.AssetCategory[] 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.asset.NoSuchCategoryException {
490                    return getPersistence()
491                                       .findByUuid_C_PrevAndNext(categoryId, uuid, companyId,
492                            orderByComparator);
493            }
494    
495            /**
496            * Removes all the asset 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 asset 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 asset 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 asset categories where groupId = &#63;.
522            *
523            * @param groupId the group ID
524            * @return the matching asset categories
525            * @throws SystemException if a system exception occurred
526            */
527            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> 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 asset 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.asset.model.impl.AssetCategoryModelImpl}. 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 asset categories
542            * @param end the upper bound of the range of asset categories (not inclusive)
543            * @return the range of matching asset categories
544            * @throws SystemException if a system exception occurred
545            */
546            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> 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 asset 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.asset.model.impl.AssetCategoryModelImpl}. 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 asset categories
561            * @param end the upper bound of the range of asset categories (not inclusive)
562            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
563            * @return the ordered range of matching asset categories
564            * @throws SystemException if a system exception occurred
565            */
566            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> 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 asset 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 asset category
580            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
581            * @throws SystemException if a system exception occurred
582            */
583            public static com.liferay.portlet.asset.model.AssetCategory 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.asset.NoSuchCategoryException {
588                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
589            }
590    
591            /**
592            * Returns the first asset 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 asset category, or <code>null</code> if a matching asset category could not be found
597            * @throws SystemException if a system exception occurred
598            */
599            public static com.liferay.portlet.asset.model.AssetCategory 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 asset 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 asset category
612            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
613            * @throws SystemException if a system exception occurred
614            */
615            public static com.liferay.portlet.asset.model.AssetCategory 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.asset.NoSuchCategoryException {
620                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
621            }
622    
623            /**
624            * Returns the last asset 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 asset category, or <code>null</code> if a matching asset category could not be found
629            * @throws SystemException if a system exception occurred
630            */
631            public static com.liferay.portlet.asset.model.AssetCategory 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 asset categories before and after the current asset category in the ordered set where groupId = &#63;.
640            *
641            * @param categoryId the primary key of the current asset 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 asset category
645            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
646            * @throws SystemException if a system exception occurred
647            */
648            public static com.liferay.portlet.asset.model.AssetCategory[] 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.asset.NoSuchCategoryException {
653                    return getPersistence()
654                                       .findByGroupId_PrevAndNext(categoryId, groupId,
655                            orderByComparator);
656            }
657    
658            /**
659            * Returns all the asset categories that the user has permission to view where groupId = &#63;.
660            *
661            * @param groupId the group ID
662            * @return the matching asset 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.asset.model.AssetCategory> 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 asset 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.asset.model.impl.AssetCategoryModelImpl}. 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 asset categories
680            * @param end the upper bound of the range of asset categories (not inclusive)
681            * @return the range of matching asset 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.asset.model.AssetCategory> 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 asset 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.asset.model.impl.AssetCategoryModelImpl}. 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 asset categories
699            * @param end the upper bound of the range of asset categories (not inclusive)
700            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
701            * @return the ordered range of matching asset 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.asset.model.AssetCategory> 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 asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = &#63;.
714            *
715            * @param categoryId the primary key of the current asset 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 asset category
719            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
720            * @throws SystemException if a system exception occurred
721            */
722            public static com.liferay.portlet.asset.model.AssetCategory[] 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.asset.NoSuchCategoryException {
727                    return getPersistence()
728                                       .filterFindByGroupId_PrevAndNext(categoryId, groupId,
729                            orderByComparator);
730            }
731    
732            /**
733            * Removes all the asset 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 asset categories where groupId = &#63;.
745            *
746            * @param groupId the group ID
747            * @return the number of matching asset 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 asset categories that the user has permission to view where groupId = &#63;.
757            *
758            * @param groupId the group ID
759            * @return the number of matching asset 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 asset categories where parentCategoryId = &#63;.
769            *
770            * @param parentCategoryId the parent category ID
771            * @return the matching asset categories
772            * @throws SystemException if a system exception occurred
773            */
774            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByParentCategoryId(
775                    long parentCategoryId)
776                    throws com.liferay.portal.kernel.exception.SystemException {
777                    return getPersistence().findByParentCategoryId(parentCategoryId);
778            }
779    
780            /**
781            * Returns a range of all the asset categories where parentCategoryId = &#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.asset.model.impl.AssetCategoryModelImpl}. 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 parentCategoryId the parent category ID
788            * @param start the lower bound of the range of asset categories
789            * @param end the upper bound of the range of asset categories (not inclusive)
790            * @return the range of matching asset categories
791            * @throws SystemException if a system exception occurred
792            */
793            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByParentCategoryId(
794                    long parentCategoryId, int start, int end)
795                    throws com.liferay.portal.kernel.exception.SystemException {
796                    return getPersistence()
797                                       .findByParentCategoryId(parentCategoryId, start, end);
798            }
799    
800            /**
801            * Returns an ordered range of all the asset categories where parentCategoryId = &#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. 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.asset.model.impl.AssetCategoryModelImpl}. 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.
805            * </p>
806            *
807            * @param parentCategoryId the parent category ID
808            * @param start the lower bound of the range of asset categories
809            * @param end the upper bound of the range of asset categories (not inclusive)
810            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
811            * @return the ordered range of matching asset categories
812            * @throws SystemException if a system exception occurred
813            */
814            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByParentCategoryId(
815                    long parentCategoryId, int start, int end,
816                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
817                    throws com.liferay.portal.kernel.exception.SystemException {
818                    return getPersistence()
819                                       .findByParentCategoryId(parentCategoryId, start, end,
820                            orderByComparator);
821            }
822    
823            /**
824            * Returns the first asset category in the ordered set where parentCategoryId = &#63;.
825            *
826            * @param parentCategoryId the parent category ID
827            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
828            * @return the first matching asset category
829            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
830            * @throws SystemException if a system exception occurred
831            */
832            public static com.liferay.portlet.asset.model.AssetCategory findByParentCategoryId_First(
833                    long parentCategoryId,
834                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
835                    throws com.liferay.portal.kernel.exception.SystemException,
836                            com.liferay.portlet.asset.NoSuchCategoryException {
837                    return getPersistence()
838                                       .findByParentCategoryId_First(parentCategoryId,
839                            orderByComparator);
840            }
841    
842            /**
843            * Returns the first asset category in the ordered set where parentCategoryId = &#63;.
844            *
845            * @param parentCategoryId the parent category ID
846            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
847            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
848            * @throws SystemException if a system exception occurred
849            */
850            public static com.liferay.portlet.asset.model.AssetCategory fetchByParentCategoryId_First(
851                    long parentCategoryId,
852                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
853                    throws com.liferay.portal.kernel.exception.SystemException {
854                    return getPersistence()
855                                       .fetchByParentCategoryId_First(parentCategoryId,
856                            orderByComparator);
857            }
858    
859            /**
860            * Returns the last asset category in the ordered set where parentCategoryId = &#63;.
861            *
862            * @param parentCategoryId the parent category ID
863            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
864            * @return the last matching asset category
865            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
866            * @throws SystemException if a system exception occurred
867            */
868            public static com.liferay.portlet.asset.model.AssetCategory findByParentCategoryId_Last(
869                    long parentCategoryId,
870                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
871                    throws com.liferay.portal.kernel.exception.SystemException,
872                            com.liferay.portlet.asset.NoSuchCategoryException {
873                    return getPersistence()
874                                       .findByParentCategoryId_Last(parentCategoryId,
875                            orderByComparator);
876            }
877    
878            /**
879            * Returns the last asset category in the ordered set where parentCategoryId = &#63;.
880            *
881            * @param parentCategoryId the parent category ID
882            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
883            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
884            * @throws SystemException if a system exception occurred
885            */
886            public static com.liferay.portlet.asset.model.AssetCategory fetchByParentCategoryId_Last(
887                    long parentCategoryId,
888                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
889                    throws com.liferay.portal.kernel.exception.SystemException {
890                    return getPersistence()
891                                       .fetchByParentCategoryId_Last(parentCategoryId,
892                            orderByComparator);
893            }
894    
895            /**
896            * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = &#63;.
897            *
898            * @param categoryId the primary key of the current asset category
899            * @param parentCategoryId the parent category ID
900            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
901            * @return the previous, current, and next asset category
902            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
903            * @throws SystemException if a system exception occurred
904            */
905            public static com.liferay.portlet.asset.model.AssetCategory[] findByParentCategoryId_PrevAndNext(
906                    long categoryId, long parentCategoryId,
907                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
908                    throws com.liferay.portal.kernel.exception.SystemException,
909                            com.liferay.portlet.asset.NoSuchCategoryException {
910                    return getPersistence()
911                                       .findByParentCategoryId_PrevAndNext(categoryId,
912                            parentCategoryId, orderByComparator);
913            }
914    
915            /**
916            * Removes all the asset categories where parentCategoryId = &#63; from the database.
917            *
918            * @param parentCategoryId the parent category ID
919            * @throws SystemException if a system exception occurred
920            */
921            public static void removeByParentCategoryId(long parentCategoryId)
922                    throws com.liferay.portal.kernel.exception.SystemException {
923                    getPersistence().removeByParentCategoryId(parentCategoryId);
924            }
925    
926            /**
927            * Returns the number of asset categories where parentCategoryId = &#63;.
928            *
929            * @param parentCategoryId the parent category ID
930            * @return the number of matching asset categories
931            * @throws SystemException if a system exception occurred
932            */
933            public static int countByParentCategoryId(long parentCategoryId)
934                    throws com.liferay.portal.kernel.exception.SystemException {
935                    return getPersistence().countByParentCategoryId(parentCategoryId);
936            }
937    
938            /**
939            * Returns all the asset categories where vocabularyId = &#63;.
940            *
941            * @param vocabularyId the vocabulary ID
942            * @return the matching asset categories
943            * @throws SystemException if a system exception occurred
944            */
945            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByVocabularyId(
946                    long vocabularyId)
947                    throws com.liferay.portal.kernel.exception.SystemException {
948                    return getPersistence().findByVocabularyId(vocabularyId);
949            }
950    
951            /**
952            * Returns a range of all the asset categories where vocabularyId = &#63;.
953            *
954            * <p>
955            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
956            * </p>
957            *
958            * @param vocabularyId the vocabulary ID
959            * @param start the lower bound of the range of asset categories
960            * @param end the upper bound of the range of asset categories (not inclusive)
961            * @return the range of matching asset categories
962            * @throws SystemException if a system exception occurred
963            */
964            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByVocabularyId(
965                    long vocabularyId, int start, int end)
966                    throws com.liferay.portal.kernel.exception.SystemException {
967                    return getPersistence().findByVocabularyId(vocabularyId, start, end);
968            }
969    
970            /**
971            * Returns an ordered range of all the asset categories where vocabularyId = &#63;.
972            *
973            * <p>
974            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
975            * </p>
976            *
977            * @param vocabularyId the vocabulary ID
978            * @param start the lower bound of the range of asset categories
979            * @param end the upper bound of the range of asset categories (not inclusive)
980            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
981            * @return the ordered range of matching asset categories
982            * @throws SystemException if a system exception occurred
983            */
984            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByVocabularyId(
985                    long vocabularyId, int start, int end,
986                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
987                    throws com.liferay.portal.kernel.exception.SystemException {
988                    return getPersistence()
989                                       .findByVocabularyId(vocabularyId, start, end,
990                            orderByComparator);
991            }
992    
993            /**
994            * Returns the first asset category in the ordered set where vocabularyId = &#63;.
995            *
996            * @param vocabularyId the vocabulary ID
997            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
998            * @return the first matching asset category
999            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1000            * @throws SystemException if a system exception occurred
1001            */
1002            public static com.liferay.portlet.asset.model.AssetCategory findByVocabularyId_First(
1003                    long vocabularyId,
1004                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1005                    throws com.liferay.portal.kernel.exception.SystemException,
1006                            com.liferay.portlet.asset.NoSuchCategoryException {
1007                    return getPersistence()
1008                                       .findByVocabularyId_First(vocabularyId, orderByComparator);
1009            }
1010    
1011            /**
1012            * Returns the first asset category in the ordered set where vocabularyId = &#63;.
1013            *
1014            * @param vocabularyId the vocabulary ID
1015            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1016            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
1017            * @throws SystemException if a system exception occurred
1018            */
1019            public static com.liferay.portlet.asset.model.AssetCategory fetchByVocabularyId_First(
1020                    long vocabularyId,
1021                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1022                    throws com.liferay.portal.kernel.exception.SystemException {
1023                    return getPersistence()
1024                                       .fetchByVocabularyId_First(vocabularyId, orderByComparator);
1025            }
1026    
1027            /**
1028            * Returns the last asset category in the ordered set where vocabularyId = &#63;.
1029            *
1030            * @param vocabularyId the vocabulary ID
1031            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1032            * @return the last matching asset category
1033            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1034            * @throws SystemException if a system exception occurred
1035            */
1036            public static com.liferay.portlet.asset.model.AssetCategory findByVocabularyId_Last(
1037                    long vocabularyId,
1038                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1039                    throws com.liferay.portal.kernel.exception.SystemException,
1040                            com.liferay.portlet.asset.NoSuchCategoryException {
1041                    return getPersistence()
1042                                       .findByVocabularyId_Last(vocabularyId, orderByComparator);
1043            }
1044    
1045            /**
1046            * Returns the last asset category in the ordered set where vocabularyId = &#63;.
1047            *
1048            * @param vocabularyId the vocabulary ID
1049            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1050            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
1051            * @throws SystemException if a system exception occurred
1052            */
1053            public static com.liferay.portlet.asset.model.AssetCategory fetchByVocabularyId_Last(
1054                    long vocabularyId,
1055                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1056                    throws com.liferay.portal.kernel.exception.SystemException {
1057                    return getPersistence()
1058                                       .fetchByVocabularyId_Last(vocabularyId, orderByComparator);
1059            }
1060    
1061            /**
1062            * Returns the asset categories before and after the current asset category in the ordered set where vocabularyId = &#63;.
1063            *
1064            * @param categoryId the primary key of the current asset category
1065            * @param vocabularyId the vocabulary ID
1066            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1067            * @return the previous, current, and next asset category
1068            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
1069            * @throws SystemException if a system exception occurred
1070            */
1071            public static com.liferay.portlet.asset.model.AssetCategory[] findByVocabularyId_PrevAndNext(
1072                    long categoryId, long vocabularyId,
1073                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1074                    throws com.liferay.portal.kernel.exception.SystemException,
1075                            com.liferay.portlet.asset.NoSuchCategoryException {
1076                    return getPersistence()
1077                                       .findByVocabularyId_PrevAndNext(categoryId, vocabularyId,
1078                            orderByComparator);
1079            }
1080    
1081            /**
1082            * Removes all the asset categories where vocabularyId = &#63; from the database.
1083            *
1084            * @param vocabularyId the vocabulary ID
1085            * @throws SystemException if a system exception occurred
1086            */
1087            public static void removeByVocabularyId(long vocabularyId)
1088                    throws com.liferay.portal.kernel.exception.SystemException {
1089                    getPersistence().removeByVocabularyId(vocabularyId);
1090            }
1091    
1092            /**
1093            * Returns the number of asset categories where vocabularyId = &#63;.
1094            *
1095            * @param vocabularyId the vocabulary ID
1096            * @return the number of matching asset categories
1097            * @throws SystemException if a system exception occurred
1098            */
1099            public static int countByVocabularyId(long vocabularyId)
1100                    throws com.liferay.portal.kernel.exception.SystemException {
1101                    return getPersistence().countByVocabularyId(vocabularyId);
1102            }
1103    
1104            /**
1105            * Returns all the asset categories where groupId = &#63; and vocabularyId = &#63;.
1106            *
1107            * @param groupId the group ID
1108            * @param vocabularyId the vocabulary ID
1109            * @return the matching asset categories
1110            * @throws SystemException if a system exception occurred
1111            */
1112            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_V(
1113                    long groupId, long vocabularyId)
1114                    throws com.liferay.portal.kernel.exception.SystemException {
1115                    return getPersistence().findByG_V(groupId, vocabularyId);
1116            }
1117    
1118            /**
1119            * Returns a range of all the asset categories where groupId = &#63; and vocabularyId = &#63;.
1120            *
1121            * <p>
1122            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1123            * </p>
1124            *
1125            * @param groupId the group ID
1126            * @param vocabularyId the vocabulary ID
1127            * @param start the lower bound of the range of asset categories
1128            * @param end the upper bound of the range of asset categories (not inclusive)
1129            * @return the range of matching asset categories
1130            * @throws SystemException if a system exception occurred
1131            */
1132            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_V(
1133                    long groupId, long vocabularyId, int start, int end)
1134                    throws com.liferay.portal.kernel.exception.SystemException {
1135                    return getPersistence().findByG_V(groupId, vocabularyId, start, end);
1136            }
1137    
1138            /**
1139            * Returns an ordered range of all the asset categories where groupId = &#63; and vocabularyId = &#63;.
1140            *
1141            * <p>
1142            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1143            * </p>
1144            *
1145            * @param groupId the group ID
1146            * @param vocabularyId the vocabulary ID
1147            * @param start the lower bound of the range of asset categories
1148            * @param end the upper bound of the range of asset categories (not inclusive)
1149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1150            * @return the ordered range of matching asset categories
1151            * @throws SystemException if a system exception occurred
1152            */
1153            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_V(
1154                    long groupId, long vocabularyId, int start, int end,
1155                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1156                    throws com.liferay.portal.kernel.exception.SystemException {
1157                    return getPersistence()
1158                                       .findByG_V(groupId, vocabularyId, start, end,
1159                            orderByComparator);
1160            }
1161    
1162            /**
1163            * Returns the first asset category in the ordered set where groupId = &#63; and vocabularyId = &#63;.
1164            *
1165            * @param groupId the group ID
1166            * @param vocabularyId the vocabulary ID
1167            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1168            * @return the first matching asset category
1169            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1170            * @throws SystemException if a system exception occurred
1171            */
1172            public static com.liferay.portlet.asset.model.AssetCategory findByG_V_First(
1173                    long groupId, long vocabularyId,
1174                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1175                    throws com.liferay.portal.kernel.exception.SystemException,
1176                            com.liferay.portlet.asset.NoSuchCategoryException {
1177                    return getPersistence()
1178                                       .findByG_V_First(groupId, vocabularyId, orderByComparator);
1179            }
1180    
1181            /**
1182            * Returns the first asset category in the ordered set where groupId = &#63; and vocabularyId = &#63;.
1183            *
1184            * @param groupId the group ID
1185            * @param vocabularyId the vocabulary ID
1186            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1187            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
1188            * @throws SystemException if a system exception occurred
1189            */
1190            public static com.liferay.portlet.asset.model.AssetCategory fetchByG_V_First(
1191                    long groupId, long vocabularyId,
1192                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1193                    throws com.liferay.portal.kernel.exception.SystemException {
1194                    return getPersistence()
1195                                       .fetchByG_V_First(groupId, vocabularyId, orderByComparator);
1196            }
1197    
1198            /**
1199            * Returns the last asset category in the ordered set where groupId = &#63; and vocabularyId = &#63;.
1200            *
1201            * @param groupId the group ID
1202            * @param vocabularyId the vocabulary ID
1203            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1204            * @return the last matching asset category
1205            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1206            * @throws SystemException if a system exception occurred
1207            */
1208            public static com.liferay.portlet.asset.model.AssetCategory findByG_V_Last(
1209                    long groupId, long vocabularyId,
1210                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1211                    throws com.liferay.portal.kernel.exception.SystemException,
1212                            com.liferay.portlet.asset.NoSuchCategoryException {
1213                    return getPersistence()
1214                                       .findByG_V_Last(groupId, vocabularyId, orderByComparator);
1215            }
1216    
1217            /**
1218            * Returns the last asset category in the ordered set where groupId = &#63; and vocabularyId = &#63;.
1219            *
1220            * @param groupId the group ID
1221            * @param vocabularyId the vocabulary ID
1222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1223            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
1224            * @throws SystemException if a system exception occurred
1225            */
1226            public static com.liferay.portlet.asset.model.AssetCategory fetchByG_V_Last(
1227                    long groupId, long vocabularyId,
1228                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1229                    throws com.liferay.portal.kernel.exception.SystemException {
1230                    return getPersistence()
1231                                       .fetchByG_V_Last(groupId, vocabularyId, orderByComparator);
1232            }
1233    
1234            /**
1235            * Returns the asset categories before and after the current asset category in the ordered set where groupId = &#63; and vocabularyId = &#63;.
1236            *
1237            * @param categoryId the primary key of the current asset category
1238            * @param groupId the group ID
1239            * @param vocabularyId the vocabulary ID
1240            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1241            * @return the previous, current, and next asset category
1242            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
1243            * @throws SystemException if a system exception occurred
1244            */
1245            public static com.liferay.portlet.asset.model.AssetCategory[] findByG_V_PrevAndNext(
1246                    long categoryId, long groupId, long vocabularyId,
1247                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1248                    throws com.liferay.portal.kernel.exception.SystemException,
1249                            com.liferay.portlet.asset.NoSuchCategoryException {
1250                    return getPersistence()
1251                                       .findByG_V_PrevAndNext(categoryId, groupId, vocabularyId,
1252                            orderByComparator);
1253            }
1254    
1255            /**
1256            * Returns all the asset categories that the user has permission to view where groupId = &#63; and vocabularyId = &#63;.
1257            *
1258            * @param groupId the group ID
1259            * @param vocabularyId the vocabulary ID
1260            * @return the matching asset categories that the user has permission to view
1261            * @throws SystemException if a system exception occurred
1262            */
1263            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_V(
1264                    long groupId, long vocabularyId)
1265                    throws com.liferay.portal.kernel.exception.SystemException {
1266                    return getPersistence().filterFindByG_V(groupId, vocabularyId);
1267            }
1268    
1269            /**
1270            * Returns a range of all the asset categories that the user has permission to view where groupId = &#63; and vocabularyId = &#63;.
1271            *
1272            * <p>
1273            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1274            * </p>
1275            *
1276            * @param groupId the group ID
1277            * @param vocabularyId the vocabulary ID
1278            * @param start the lower bound of the range of asset categories
1279            * @param end the upper bound of the range of asset categories (not inclusive)
1280            * @return the range of matching asset categories that the user has permission to view
1281            * @throws SystemException if a system exception occurred
1282            */
1283            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_V(
1284                    long groupId, long vocabularyId, int start, int end)
1285                    throws com.liferay.portal.kernel.exception.SystemException {
1286                    return getPersistence()
1287                                       .filterFindByG_V(groupId, vocabularyId, start, end);
1288            }
1289    
1290            /**
1291            * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = &#63; and vocabularyId = &#63;.
1292            *
1293            * <p>
1294            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1295            * </p>
1296            *
1297            * @param groupId the group ID
1298            * @param vocabularyId the vocabulary ID
1299            * @param start the lower bound of the range of asset categories
1300            * @param end the upper bound of the range of asset categories (not inclusive)
1301            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1302            * @return the ordered range of matching asset categories that the user has permission to view
1303            * @throws SystemException if a system exception occurred
1304            */
1305            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_V(
1306                    long groupId, long vocabularyId, int start, int end,
1307                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1308                    throws com.liferay.portal.kernel.exception.SystemException {
1309                    return getPersistence()
1310                                       .filterFindByG_V(groupId, vocabularyId, start, end,
1311                            orderByComparator);
1312            }
1313    
1314            /**
1315            * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = &#63; and vocabularyId = &#63;.
1316            *
1317            * @param categoryId the primary key of the current asset category
1318            * @param groupId the group ID
1319            * @param vocabularyId the vocabulary ID
1320            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1321            * @return the previous, current, and next asset category
1322            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
1323            * @throws SystemException if a system exception occurred
1324            */
1325            public static com.liferay.portlet.asset.model.AssetCategory[] filterFindByG_V_PrevAndNext(
1326                    long categoryId, long groupId, long vocabularyId,
1327                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1328                    throws com.liferay.portal.kernel.exception.SystemException,
1329                            com.liferay.portlet.asset.NoSuchCategoryException {
1330                    return getPersistence()
1331                                       .filterFindByG_V_PrevAndNext(categoryId, groupId,
1332                            vocabularyId, orderByComparator);
1333            }
1334    
1335            /**
1336            * Returns all the asset categories that the user has permission to view where groupId = &#63; and vocabularyId = any &#63;.
1337            *
1338            * @param groupId the group ID
1339            * @param vocabularyIds the vocabulary IDs
1340            * @return the matching asset categories that the user has permission to view
1341            * @throws SystemException if a system exception occurred
1342            */
1343            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_V(
1344                    long groupId, long[] vocabularyIds)
1345                    throws com.liferay.portal.kernel.exception.SystemException {
1346                    return getPersistence().filterFindByG_V(groupId, vocabularyIds);
1347            }
1348    
1349            /**
1350            * Returns a range of all the asset categories that the user has permission to view where groupId = &#63; and vocabularyId = any &#63;.
1351            *
1352            * <p>
1353            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1354            * </p>
1355            *
1356            * @param groupId the group ID
1357            * @param vocabularyIds the vocabulary IDs
1358            * @param start the lower bound of the range of asset categories
1359            * @param end the upper bound of the range of asset categories (not inclusive)
1360            * @return the range of matching asset categories that the user has permission to view
1361            * @throws SystemException if a system exception occurred
1362            */
1363            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_V(
1364                    long groupId, long[] vocabularyIds, int start, int end)
1365                    throws com.liferay.portal.kernel.exception.SystemException {
1366                    return getPersistence()
1367                                       .filterFindByG_V(groupId, vocabularyIds, start, end);
1368            }
1369    
1370            /**
1371            * Returns an ordered range of all the asset categories that the user has permission to view where groupId = &#63; and vocabularyId = any &#63;.
1372            *
1373            * <p>
1374            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1375            * </p>
1376            *
1377            * @param groupId the group ID
1378            * @param vocabularyIds the vocabulary IDs
1379            * @param start the lower bound of the range of asset categories
1380            * @param end the upper bound of the range of asset categories (not inclusive)
1381            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1382            * @return the ordered range of matching asset categories that the user has permission to view
1383            * @throws SystemException if a system exception occurred
1384            */
1385            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_V(
1386                    long groupId, long[] vocabularyIds, int start, int end,
1387                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1388                    throws com.liferay.portal.kernel.exception.SystemException {
1389                    return getPersistence()
1390                                       .filterFindByG_V(groupId, vocabularyIds, start, end,
1391                            orderByComparator);
1392            }
1393    
1394            /**
1395            * Returns all the asset categories where groupId = &#63; and vocabularyId = any &#63;.
1396            *
1397            * <p>
1398            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1399            * </p>
1400            *
1401            * @param groupId the group ID
1402            * @param vocabularyIds the vocabulary IDs
1403            * @return the matching asset categories
1404            * @throws SystemException if a system exception occurred
1405            */
1406            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_V(
1407                    long groupId, long[] vocabularyIds)
1408                    throws com.liferay.portal.kernel.exception.SystemException {
1409                    return getPersistence().findByG_V(groupId, vocabularyIds);
1410            }
1411    
1412            /**
1413            * Returns a range of all the asset categories where groupId = &#63; and vocabularyId = any &#63;.
1414            *
1415            * <p>
1416            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1417            * </p>
1418            *
1419            * @param groupId the group ID
1420            * @param vocabularyIds the vocabulary IDs
1421            * @param start the lower bound of the range of asset categories
1422            * @param end the upper bound of the range of asset categories (not inclusive)
1423            * @return the range of matching asset categories
1424            * @throws SystemException if a system exception occurred
1425            */
1426            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_V(
1427                    long groupId, long[] vocabularyIds, int start, int end)
1428                    throws com.liferay.portal.kernel.exception.SystemException {
1429                    return getPersistence().findByG_V(groupId, vocabularyIds, start, end);
1430            }
1431    
1432            /**
1433            * Returns an ordered range of all the asset categories where groupId = &#63; and vocabularyId = any &#63;.
1434            *
1435            * <p>
1436            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1437            * </p>
1438            *
1439            * @param groupId the group ID
1440            * @param vocabularyIds the vocabulary IDs
1441            * @param start the lower bound of the range of asset categories
1442            * @param end the upper bound of the range of asset categories (not inclusive)
1443            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1444            * @return the ordered range of matching asset categories
1445            * @throws SystemException if a system exception occurred
1446            */
1447            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_V(
1448                    long groupId, long[] vocabularyIds, int start, int end,
1449                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1450                    throws com.liferay.portal.kernel.exception.SystemException {
1451                    return getPersistence()
1452                                       .findByG_V(groupId, vocabularyIds, start, end,
1453                            orderByComparator);
1454            }
1455    
1456            /**
1457            * Removes all the asset categories where groupId = &#63; and vocabularyId = &#63; from the database.
1458            *
1459            * @param groupId the group ID
1460            * @param vocabularyId the vocabulary ID
1461            * @throws SystemException if a system exception occurred
1462            */
1463            public static void removeByG_V(long groupId, long vocabularyId)
1464                    throws com.liferay.portal.kernel.exception.SystemException {
1465                    getPersistence().removeByG_V(groupId, vocabularyId);
1466            }
1467    
1468            /**
1469            * Returns the number of asset categories where groupId = &#63; and vocabularyId = &#63;.
1470            *
1471            * @param groupId the group ID
1472            * @param vocabularyId the vocabulary ID
1473            * @return the number of matching asset categories
1474            * @throws SystemException if a system exception occurred
1475            */
1476            public static int countByG_V(long groupId, long vocabularyId)
1477                    throws com.liferay.portal.kernel.exception.SystemException {
1478                    return getPersistence().countByG_V(groupId, vocabularyId);
1479            }
1480    
1481            /**
1482            * Returns the number of asset categories where groupId = &#63; and vocabularyId = any &#63;.
1483            *
1484            * @param groupId the group ID
1485            * @param vocabularyIds the vocabulary IDs
1486            * @return the number of matching asset categories
1487            * @throws SystemException if a system exception occurred
1488            */
1489            public static int countByG_V(long groupId, long[] vocabularyIds)
1490                    throws com.liferay.portal.kernel.exception.SystemException {
1491                    return getPersistence().countByG_V(groupId, vocabularyIds);
1492            }
1493    
1494            /**
1495            * Returns the number of asset categories that the user has permission to view where groupId = &#63; and vocabularyId = &#63;.
1496            *
1497            * @param groupId the group ID
1498            * @param vocabularyId the vocabulary ID
1499            * @return the number of matching asset categories that the user has permission to view
1500            * @throws SystemException if a system exception occurred
1501            */
1502            public static int filterCountByG_V(long groupId, long vocabularyId)
1503                    throws com.liferay.portal.kernel.exception.SystemException {
1504                    return getPersistence().filterCountByG_V(groupId, vocabularyId);
1505            }
1506    
1507            /**
1508            * Returns the number of asset categories that the user has permission to view where groupId = &#63; and vocabularyId = any &#63;.
1509            *
1510            * @param groupId the group ID
1511            * @param vocabularyIds the vocabulary IDs
1512            * @return the number of matching asset categories that the user has permission to view
1513            * @throws SystemException if a system exception occurred
1514            */
1515            public static int filterCountByG_V(long groupId, long[] vocabularyIds)
1516                    throws com.liferay.portal.kernel.exception.SystemException {
1517                    return getPersistence().filterCountByG_V(groupId, vocabularyIds);
1518            }
1519    
1520            /**
1521            * Returns all the asset categories where parentCategoryId = &#63; and name = &#63;.
1522            *
1523            * @param parentCategoryId the parent category ID
1524            * @param name the name
1525            * @return the matching asset categories
1526            * @throws SystemException if a system exception occurred
1527            */
1528            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_N(
1529                    long parentCategoryId, java.lang.String name)
1530                    throws com.liferay.portal.kernel.exception.SystemException {
1531                    return getPersistence().findByP_N(parentCategoryId, name);
1532            }
1533    
1534            /**
1535            * Returns a range of all the asset categories where parentCategoryId = &#63; and name = &#63;.
1536            *
1537            * <p>
1538            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1539            * </p>
1540            *
1541            * @param parentCategoryId the parent category ID
1542            * @param name the name
1543            * @param start the lower bound of the range of asset categories
1544            * @param end the upper bound of the range of asset categories (not inclusive)
1545            * @return the range of matching asset categories
1546            * @throws SystemException if a system exception occurred
1547            */
1548            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_N(
1549                    long parentCategoryId, java.lang.String name, int start, int end)
1550                    throws com.liferay.portal.kernel.exception.SystemException {
1551                    return getPersistence().findByP_N(parentCategoryId, name, start, end);
1552            }
1553    
1554            /**
1555            * Returns an ordered range of all the asset categories where parentCategoryId = &#63; and name = &#63;.
1556            *
1557            * <p>
1558            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1559            * </p>
1560            *
1561            * @param parentCategoryId the parent category ID
1562            * @param name the name
1563            * @param start the lower bound of the range of asset categories
1564            * @param end the upper bound of the range of asset categories (not inclusive)
1565            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1566            * @return the ordered range of matching asset categories
1567            * @throws SystemException if a system exception occurred
1568            */
1569            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_N(
1570                    long parentCategoryId, java.lang.String name, int start, int end,
1571                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1572                    throws com.liferay.portal.kernel.exception.SystemException {
1573                    return getPersistence()
1574                                       .findByP_N(parentCategoryId, name, start, end,
1575                            orderByComparator);
1576            }
1577    
1578            /**
1579            * Returns the first asset category in the ordered set where parentCategoryId = &#63; and name = &#63;.
1580            *
1581            * @param parentCategoryId the parent category ID
1582            * @param name the name
1583            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1584            * @return the first matching asset category
1585            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1586            * @throws SystemException if a system exception occurred
1587            */
1588            public static com.liferay.portlet.asset.model.AssetCategory findByP_N_First(
1589                    long parentCategoryId, java.lang.String name,
1590                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1591                    throws com.liferay.portal.kernel.exception.SystemException,
1592                            com.liferay.portlet.asset.NoSuchCategoryException {
1593                    return getPersistence()
1594                                       .findByP_N_First(parentCategoryId, name, orderByComparator);
1595            }
1596    
1597            /**
1598            * Returns the first asset category in the ordered set where parentCategoryId = &#63; and name = &#63;.
1599            *
1600            * @param parentCategoryId the parent category ID
1601            * @param name the name
1602            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1603            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
1604            * @throws SystemException if a system exception occurred
1605            */
1606            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_First(
1607                    long parentCategoryId, java.lang.String name,
1608                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1609                    throws com.liferay.portal.kernel.exception.SystemException {
1610                    return getPersistence()
1611                                       .fetchByP_N_First(parentCategoryId, name, orderByComparator);
1612            }
1613    
1614            /**
1615            * Returns the last asset category in the ordered set where parentCategoryId = &#63; and name = &#63;.
1616            *
1617            * @param parentCategoryId the parent category ID
1618            * @param name the name
1619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1620            * @return the last matching asset category
1621            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1622            * @throws SystemException if a system exception occurred
1623            */
1624            public static com.liferay.portlet.asset.model.AssetCategory findByP_N_Last(
1625                    long parentCategoryId, java.lang.String name,
1626                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1627                    throws com.liferay.portal.kernel.exception.SystemException,
1628                            com.liferay.portlet.asset.NoSuchCategoryException {
1629                    return getPersistence()
1630                                       .findByP_N_Last(parentCategoryId, name, orderByComparator);
1631            }
1632    
1633            /**
1634            * Returns the last asset category in the ordered set where parentCategoryId = &#63; and name = &#63;.
1635            *
1636            * @param parentCategoryId the parent category ID
1637            * @param name the name
1638            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1639            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
1640            * @throws SystemException if a system exception occurred
1641            */
1642            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_Last(
1643                    long parentCategoryId, java.lang.String name,
1644                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1645                    throws com.liferay.portal.kernel.exception.SystemException {
1646                    return getPersistence()
1647                                       .fetchByP_N_Last(parentCategoryId, name, orderByComparator);
1648            }
1649    
1650            /**
1651            * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = &#63; and name = &#63;.
1652            *
1653            * @param categoryId the primary key of the current asset category
1654            * @param parentCategoryId the parent category ID
1655            * @param name the name
1656            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1657            * @return the previous, current, and next asset category
1658            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
1659            * @throws SystemException if a system exception occurred
1660            */
1661            public static com.liferay.portlet.asset.model.AssetCategory[] findByP_N_PrevAndNext(
1662                    long categoryId, long parentCategoryId, java.lang.String name,
1663                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1664                    throws com.liferay.portal.kernel.exception.SystemException,
1665                            com.liferay.portlet.asset.NoSuchCategoryException {
1666                    return getPersistence()
1667                                       .findByP_N_PrevAndNext(categoryId, parentCategoryId, name,
1668                            orderByComparator);
1669            }
1670    
1671            /**
1672            * Removes all the asset categories where parentCategoryId = &#63; and name = &#63; from the database.
1673            *
1674            * @param parentCategoryId the parent category ID
1675            * @param name the name
1676            * @throws SystemException if a system exception occurred
1677            */
1678            public static void removeByP_N(long parentCategoryId, java.lang.String name)
1679                    throws com.liferay.portal.kernel.exception.SystemException {
1680                    getPersistence().removeByP_N(parentCategoryId, name);
1681            }
1682    
1683            /**
1684            * Returns the number of asset categories where parentCategoryId = &#63; and name = &#63;.
1685            *
1686            * @param parentCategoryId the parent category ID
1687            * @param name the name
1688            * @return the number of matching asset categories
1689            * @throws SystemException if a system exception occurred
1690            */
1691            public static int countByP_N(long parentCategoryId, java.lang.String name)
1692                    throws com.liferay.portal.kernel.exception.SystemException {
1693                    return getPersistence().countByP_N(parentCategoryId, name);
1694            }
1695    
1696            /**
1697            * Returns all the asset categories where parentCategoryId = &#63; and vocabularyId = &#63;.
1698            *
1699            * @param parentCategoryId the parent category ID
1700            * @param vocabularyId the vocabulary ID
1701            * @return the matching asset categories
1702            * @throws SystemException if a system exception occurred
1703            */
1704            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_V(
1705                    long parentCategoryId, long vocabularyId)
1706                    throws com.liferay.portal.kernel.exception.SystemException {
1707                    return getPersistence().findByP_V(parentCategoryId, vocabularyId);
1708            }
1709    
1710            /**
1711            * Returns a range of all the asset categories where parentCategoryId = &#63; and vocabularyId = &#63;.
1712            *
1713            * <p>
1714            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1715            * </p>
1716            *
1717            * @param parentCategoryId the parent category ID
1718            * @param vocabularyId the vocabulary ID
1719            * @param start the lower bound of the range of asset categories
1720            * @param end the upper bound of the range of asset categories (not inclusive)
1721            * @return the range of matching asset categories
1722            * @throws SystemException if a system exception occurred
1723            */
1724            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_V(
1725                    long parentCategoryId, long vocabularyId, int start, int end)
1726                    throws com.liferay.portal.kernel.exception.SystemException {
1727                    return getPersistence()
1728                                       .findByP_V(parentCategoryId, vocabularyId, start, end);
1729            }
1730    
1731            /**
1732            * Returns an ordered range of all the asset categories where parentCategoryId = &#63; and vocabularyId = &#63;.
1733            *
1734            * <p>
1735            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1736            * </p>
1737            *
1738            * @param parentCategoryId the parent category ID
1739            * @param vocabularyId the vocabulary ID
1740            * @param start the lower bound of the range of asset categories
1741            * @param end the upper bound of the range of asset categories (not inclusive)
1742            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1743            * @return the ordered range of matching asset categories
1744            * @throws SystemException if a system exception occurred
1745            */
1746            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_V(
1747                    long parentCategoryId, long vocabularyId, int start, int end,
1748                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1749                    throws com.liferay.portal.kernel.exception.SystemException {
1750                    return getPersistence()
1751                                       .findByP_V(parentCategoryId, vocabularyId, start, end,
1752                            orderByComparator);
1753            }
1754    
1755            /**
1756            * Returns the first asset category in the ordered set where parentCategoryId = &#63; and vocabularyId = &#63;.
1757            *
1758            * @param parentCategoryId the parent category ID
1759            * @param vocabularyId the vocabulary ID
1760            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1761            * @return the first matching asset category
1762            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1763            * @throws SystemException if a system exception occurred
1764            */
1765            public static com.liferay.portlet.asset.model.AssetCategory findByP_V_First(
1766                    long parentCategoryId, long vocabularyId,
1767                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1768                    throws com.liferay.portal.kernel.exception.SystemException,
1769                            com.liferay.portlet.asset.NoSuchCategoryException {
1770                    return getPersistence()
1771                                       .findByP_V_First(parentCategoryId, vocabularyId,
1772                            orderByComparator);
1773            }
1774    
1775            /**
1776            * Returns the first asset category in the ordered set where parentCategoryId = &#63; and vocabularyId = &#63;.
1777            *
1778            * @param parentCategoryId the parent category ID
1779            * @param vocabularyId the vocabulary ID
1780            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1781            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
1782            * @throws SystemException if a system exception occurred
1783            */
1784            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_V_First(
1785                    long parentCategoryId, long vocabularyId,
1786                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1787                    throws com.liferay.portal.kernel.exception.SystemException {
1788                    return getPersistence()
1789                                       .fetchByP_V_First(parentCategoryId, vocabularyId,
1790                            orderByComparator);
1791            }
1792    
1793            /**
1794            * Returns the last asset category in the ordered set where parentCategoryId = &#63; and vocabularyId = &#63;.
1795            *
1796            * @param parentCategoryId the parent category ID
1797            * @param vocabularyId the vocabulary ID
1798            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1799            * @return the last matching asset category
1800            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1801            * @throws SystemException if a system exception occurred
1802            */
1803            public static com.liferay.portlet.asset.model.AssetCategory findByP_V_Last(
1804                    long parentCategoryId, long vocabularyId,
1805                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1806                    throws com.liferay.portal.kernel.exception.SystemException,
1807                            com.liferay.portlet.asset.NoSuchCategoryException {
1808                    return getPersistence()
1809                                       .findByP_V_Last(parentCategoryId, vocabularyId,
1810                            orderByComparator);
1811            }
1812    
1813            /**
1814            * Returns the last asset category in the ordered set where parentCategoryId = &#63; and vocabularyId = &#63;.
1815            *
1816            * @param parentCategoryId the parent category ID
1817            * @param vocabularyId the vocabulary ID
1818            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1819            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
1820            * @throws SystemException if a system exception occurred
1821            */
1822            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_V_Last(
1823                    long parentCategoryId, long vocabularyId,
1824                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1825                    throws com.liferay.portal.kernel.exception.SystemException {
1826                    return getPersistence()
1827                                       .fetchByP_V_Last(parentCategoryId, vocabularyId,
1828                            orderByComparator);
1829            }
1830    
1831            /**
1832            * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = &#63; and vocabularyId = &#63;.
1833            *
1834            * @param categoryId the primary key of the current asset category
1835            * @param parentCategoryId the parent category ID
1836            * @param vocabularyId the vocabulary ID
1837            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1838            * @return the previous, current, and next asset category
1839            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
1840            * @throws SystemException if a system exception occurred
1841            */
1842            public static com.liferay.portlet.asset.model.AssetCategory[] findByP_V_PrevAndNext(
1843                    long categoryId, long parentCategoryId, long vocabularyId,
1844                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1845                    throws com.liferay.portal.kernel.exception.SystemException,
1846                            com.liferay.portlet.asset.NoSuchCategoryException {
1847                    return getPersistence()
1848                                       .findByP_V_PrevAndNext(categoryId, parentCategoryId,
1849                            vocabularyId, orderByComparator);
1850            }
1851    
1852            /**
1853            * Removes all the asset categories where parentCategoryId = &#63; and vocabularyId = &#63; from the database.
1854            *
1855            * @param parentCategoryId the parent category ID
1856            * @param vocabularyId the vocabulary ID
1857            * @throws SystemException if a system exception occurred
1858            */
1859            public static void removeByP_V(long parentCategoryId, long vocabularyId)
1860                    throws com.liferay.portal.kernel.exception.SystemException {
1861                    getPersistence().removeByP_V(parentCategoryId, vocabularyId);
1862            }
1863    
1864            /**
1865            * Returns the number of asset categories where parentCategoryId = &#63; and vocabularyId = &#63;.
1866            *
1867            * @param parentCategoryId the parent category ID
1868            * @param vocabularyId the vocabulary ID
1869            * @return the number of matching asset categories
1870            * @throws SystemException if a system exception occurred
1871            */
1872            public static int countByP_V(long parentCategoryId, long vocabularyId)
1873                    throws com.liferay.portal.kernel.exception.SystemException {
1874                    return getPersistence().countByP_V(parentCategoryId, vocabularyId);
1875            }
1876    
1877            /**
1878            * Returns all the asset categories where name = &#63; and vocabularyId = &#63;.
1879            *
1880            * @param name the name
1881            * @param vocabularyId the vocabulary ID
1882            * @return the matching asset categories
1883            * @throws SystemException if a system exception occurred
1884            */
1885            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByN_V(
1886                    java.lang.String name, long vocabularyId)
1887                    throws com.liferay.portal.kernel.exception.SystemException {
1888                    return getPersistence().findByN_V(name, vocabularyId);
1889            }
1890    
1891            /**
1892            * Returns a range of all the asset categories where name = &#63; and vocabularyId = &#63;.
1893            *
1894            * <p>
1895            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1896            * </p>
1897            *
1898            * @param name the name
1899            * @param vocabularyId the vocabulary ID
1900            * @param start the lower bound of the range of asset categories
1901            * @param end the upper bound of the range of asset categories (not inclusive)
1902            * @return the range of matching asset categories
1903            * @throws SystemException if a system exception occurred
1904            */
1905            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByN_V(
1906                    java.lang.String name, long vocabularyId, int start, int end)
1907                    throws com.liferay.portal.kernel.exception.SystemException {
1908                    return getPersistence().findByN_V(name, vocabularyId, start, end);
1909            }
1910    
1911            /**
1912            * Returns an ordered range of all the asset categories where name = &#63; and vocabularyId = &#63;.
1913            *
1914            * <p>
1915            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
1916            * </p>
1917            *
1918            * @param name the name
1919            * @param vocabularyId the vocabulary ID
1920            * @param start the lower bound of the range of asset categories
1921            * @param end the upper bound of the range of asset categories (not inclusive)
1922            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1923            * @return the ordered range of matching asset categories
1924            * @throws SystemException if a system exception occurred
1925            */
1926            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByN_V(
1927                    java.lang.String name, long vocabularyId, int start, int end,
1928                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1929                    throws com.liferay.portal.kernel.exception.SystemException {
1930                    return getPersistence()
1931                                       .findByN_V(name, vocabularyId, start, end, orderByComparator);
1932            }
1933    
1934            /**
1935            * Returns the first asset category in the ordered set where name = &#63; and vocabularyId = &#63;.
1936            *
1937            * @param name the name
1938            * @param vocabularyId the vocabulary ID
1939            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1940            * @return the first matching asset category
1941            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1942            * @throws SystemException if a system exception occurred
1943            */
1944            public static com.liferay.portlet.asset.model.AssetCategory findByN_V_First(
1945                    java.lang.String name, long vocabularyId,
1946                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1947                    throws com.liferay.portal.kernel.exception.SystemException,
1948                            com.liferay.portlet.asset.NoSuchCategoryException {
1949                    return getPersistence()
1950                                       .findByN_V_First(name, vocabularyId, orderByComparator);
1951            }
1952    
1953            /**
1954            * Returns the first asset category in the ordered set where name = &#63; and vocabularyId = &#63;.
1955            *
1956            * @param name the name
1957            * @param vocabularyId the vocabulary ID
1958            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1959            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
1960            * @throws SystemException if a system exception occurred
1961            */
1962            public static com.liferay.portlet.asset.model.AssetCategory fetchByN_V_First(
1963                    java.lang.String name, long vocabularyId,
1964                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1965                    throws com.liferay.portal.kernel.exception.SystemException {
1966                    return getPersistence()
1967                                       .fetchByN_V_First(name, vocabularyId, orderByComparator);
1968            }
1969    
1970            /**
1971            * Returns the last asset category in the ordered set where name = &#63; and vocabularyId = &#63;.
1972            *
1973            * @param name the name
1974            * @param vocabularyId the vocabulary ID
1975            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1976            * @return the last matching asset category
1977            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1978            * @throws SystemException if a system exception occurred
1979            */
1980            public static com.liferay.portlet.asset.model.AssetCategory findByN_V_Last(
1981                    java.lang.String name, long vocabularyId,
1982                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1983                    throws com.liferay.portal.kernel.exception.SystemException,
1984                            com.liferay.portlet.asset.NoSuchCategoryException {
1985                    return getPersistence()
1986                                       .findByN_V_Last(name, vocabularyId, orderByComparator);
1987            }
1988    
1989            /**
1990            * Returns the last asset category in the ordered set where name = &#63; and vocabularyId = &#63;.
1991            *
1992            * @param name the name
1993            * @param vocabularyId the vocabulary ID
1994            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1995            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
1996            * @throws SystemException if a system exception occurred
1997            */
1998            public static com.liferay.portlet.asset.model.AssetCategory fetchByN_V_Last(
1999                    java.lang.String name, long vocabularyId,
2000                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2001                    throws com.liferay.portal.kernel.exception.SystemException {
2002                    return getPersistence()
2003                                       .fetchByN_V_Last(name, vocabularyId, orderByComparator);
2004            }
2005    
2006            /**
2007            * Returns the asset categories before and after the current asset category in the ordered set where name = &#63; and vocabularyId = &#63;.
2008            *
2009            * @param categoryId the primary key of the current asset category
2010            * @param name the name
2011            * @param vocabularyId the vocabulary ID
2012            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2013            * @return the previous, current, and next asset category
2014            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
2015            * @throws SystemException if a system exception occurred
2016            */
2017            public static com.liferay.portlet.asset.model.AssetCategory[] findByN_V_PrevAndNext(
2018                    long categoryId, java.lang.String name, long vocabularyId,
2019                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2020                    throws com.liferay.portal.kernel.exception.SystemException,
2021                            com.liferay.portlet.asset.NoSuchCategoryException {
2022                    return getPersistence()
2023                                       .findByN_V_PrevAndNext(categoryId, name, vocabularyId,
2024                            orderByComparator);
2025            }
2026    
2027            /**
2028            * Removes all the asset categories where name = &#63; and vocabularyId = &#63; from the database.
2029            *
2030            * @param name the name
2031            * @param vocabularyId the vocabulary ID
2032            * @throws SystemException if a system exception occurred
2033            */
2034            public static void removeByN_V(java.lang.String name, long vocabularyId)
2035                    throws com.liferay.portal.kernel.exception.SystemException {
2036                    getPersistence().removeByN_V(name, vocabularyId);
2037            }
2038    
2039            /**
2040            * Returns the number of asset categories where name = &#63; and vocabularyId = &#63;.
2041            *
2042            * @param name the name
2043            * @param vocabularyId the vocabulary ID
2044            * @return the number of matching asset categories
2045            * @throws SystemException if a system exception occurred
2046            */
2047            public static int countByN_V(java.lang.String name, long vocabularyId)
2048                    throws com.liferay.portal.kernel.exception.SystemException {
2049                    return getPersistence().countByN_V(name, vocabularyId);
2050            }
2051    
2052            /**
2053            * Returns all the asset categories where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2054            *
2055            * @param groupId the group ID
2056            * @param parentCategoryId the parent category ID
2057            * @param vocabularyId the vocabulary ID
2058            * @return the matching asset categories
2059            * @throws SystemException if a system exception occurred
2060            */
2061            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_V(
2062                    long groupId, long parentCategoryId, long vocabularyId)
2063                    throws com.liferay.portal.kernel.exception.SystemException {
2064                    return getPersistence()
2065                                       .findByG_P_V(groupId, parentCategoryId, vocabularyId);
2066            }
2067    
2068            /**
2069            * Returns a range of all the asset categories where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2070            *
2071            * <p>
2072            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2073            * </p>
2074            *
2075            * @param groupId the group ID
2076            * @param parentCategoryId the parent category ID
2077            * @param vocabularyId the vocabulary ID
2078            * @param start the lower bound of the range of asset categories
2079            * @param end the upper bound of the range of asset categories (not inclusive)
2080            * @return the range of matching asset categories
2081            * @throws SystemException if a system exception occurred
2082            */
2083            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_V(
2084                    long groupId, long parentCategoryId, long vocabularyId, int start,
2085                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2086                    return getPersistence()
2087                                       .findByG_P_V(groupId, parentCategoryId, vocabularyId, start,
2088                            end);
2089            }
2090    
2091            /**
2092            * Returns an ordered range of all the asset categories where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2093            *
2094            * <p>
2095            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2096            * </p>
2097            *
2098            * @param groupId the group ID
2099            * @param parentCategoryId the parent category ID
2100            * @param vocabularyId the vocabulary ID
2101            * @param start the lower bound of the range of asset categories
2102            * @param end the upper bound of the range of asset categories (not inclusive)
2103            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2104            * @return the ordered range of matching asset categories
2105            * @throws SystemException if a system exception occurred
2106            */
2107            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_V(
2108                    long groupId, long parentCategoryId, long vocabularyId, int start,
2109                    int end,
2110                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2111                    throws com.liferay.portal.kernel.exception.SystemException {
2112                    return getPersistence()
2113                                       .findByG_P_V(groupId, parentCategoryId, vocabularyId, start,
2114                            end, orderByComparator);
2115            }
2116    
2117            /**
2118            * Returns the first asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2119            *
2120            * @param groupId the group ID
2121            * @param parentCategoryId the parent category ID
2122            * @param vocabularyId the vocabulary ID
2123            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2124            * @return the first matching asset category
2125            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
2126            * @throws SystemException if a system exception occurred
2127            */
2128            public static com.liferay.portlet.asset.model.AssetCategory findByG_P_V_First(
2129                    long groupId, long parentCategoryId, long vocabularyId,
2130                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2131                    throws com.liferay.portal.kernel.exception.SystemException,
2132                            com.liferay.portlet.asset.NoSuchCategoryException {
2133                    return getPersistence()
2134                                       .findByG_P_V_First(groupId, parentCategoryId, vocabularyId,
2135                            orderByComparator);
2136            }
2137    
2138            /**
2139            * Returns the first asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2140            *
2141            * @param groupId the group ID
2142            * @param parentCategoryId the parent category ID
2143            * @param vocabularyId the vocabulary ID
2144            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2145            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
2146            * @throws SystemException if a system exception occurred
2147            */
2148            public static com.liferay.portlet.asset.model.AssetCategory fetchByG_P_V_First(
2149                    long groupId, long parentCategoryId, long vocabularyId,
2150                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2151                    throws com.liferay.portal.kernel.exception.SystemException {
2152                    return getPersistence()
2153                                       .fetchByG_P_V_First(groupId, parentCategoryId, vocabularyId,
2154                            orderByComparator);
2155            }
2156    
2157            /**
2158            * Returns the last asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2159            *
2160            * @param groupId the group ID
2161            * @param parentCategoryId the parent category ID
2162            * @param vocabularyId the vocabulary ID
2163            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2164            * @return the last matching asset category
2165            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
2166            * @throws SystemException if a system exception occurred
2167            */
2168            public static com.liferay.portlet.asset.model.AssetCategory findByG_P_V_Last(
2169                    long groupId, long parentCategoryId, long vocabularyId,
2170                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2171                    throws com.liferay.portal.kernel.exception.SystemException,
2172                            com.liferay.portlet.asset.NoSuchCategoryException {
2173                    return getPersistence()
2174                                       .findByG_P_V_Last(groupId, parentCategoryId, vocabularyId,
2175                            orderByComparator);
2176            }
2177    
2178            /**
2179            * Returns the last asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2180            *
2181            * @param groupId the group ID
2182            * @param parentCategoryId the parent category ID
2183            * @param vocabularyId the vocabulary ID
2184            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2185            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
2186            * @throws SystemException if a system exception occurred
2187            */
2188            public static com.liferay.portlet.asset.model.AssetCategory fetchByG_P_V_Last(
2189                    long groupId, long parentCategoryId, long vocabularyId,
2190                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2191                    throws com.liferay.portal.kernel.exception.SystemException {
2192                    return getPersistence()
2193                                       .fetchByG_P_V_Last(groupId, parentCategoryId, vocabularyId,
2194                            orderByComparator);
2195            }
2196    
2197            /**
2198            * Returns the asset categories before and after the current asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2199            *
2200            * @param categoryId the primary key of the current asset category
2201            * @param groupId the group ID
2202            * @param parentCategoryId the parent category ID
2203            * @param vocabularyId the vocabulary ID
2204            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2205            * @return the previous, current, and next asset category
2206            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
2207            * @throws SystemException if a system exception occurred
2208            */
2209            public static com.liferay.portlet.asset.model.AssetCategory[] findByG_P_V_PrevAndNext(
2210                    long categoryId, long groupId, long parentCategoryId,
2211                    long vocabularyId,
2212                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2213                    throws com.liferay.portal.kernel.exception.SystemException,
2214                            com.liferay.portlet.asset.NoSuchCategoryException {
2215                    return getPersistence()
2216                                       .findByG_P_V_PrevAndNext(categoryId, groupId,
2217                            parentCategoryId, vocabularyId, orderByComparator);
2218            }
2219    
2220            /**
2221            * Returns all the asset categories that the user has permission to view where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2222            *
2223            * @param groupId the group ID
2224            * @param parentCategoryId the parent category ID
2225            * @param vocabularyId the vocabulary ID
2226            * @return the matching asset categories that the user has permission to view
2227            * @throws SystemException if a system exception occurred
2228            */
2229            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_V(
2230                    long groupId, long parentCategoryId, long vocabularyId)
2231                    throws com.liferay.portal.kernel.exception.SystemException {
2232                    return getPersistence()
2233                                       .filterFindByG_P_V(groupId, parentCategoryId, vocabularyId);
2234            }
2235    
2236            /**
2237            * Returns a range of all the asset categories that the user has permission to view where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2238            *
2239            * <p>
2240            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2241            * </p>
2242            *
2243            * @param groupId the group ID
2244            * @param parentCategoryId the parent category ID
2245            * @param vocabularyId the vocabulary ID
2246            * @param start the lower bound of the range of asset categories
2247            * @param end the upper bound of the range of asset categories (not inclusive)
2248            * @return the range of matching asset categories that the user has permission to view
2249            * @throws SystemException if a system exception occurred
2250            */
2251            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_V(
2252                    long groupId, long parentCategoryId, long vocabularyId, int start,
2253                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2254                    return getPersistence()
2255                                       .filterFindByG_P_V(groupId, parentCategoryId, vocabularyId,
2256                            start, end);
2257            }
2258    
2259            /**
2260            * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2261            *
2262            * <p>
2263            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2264            * </p>
2265            *
2266            * @param groupId the group ID
2267            * @param parentCategoryId the parent category ID
2268            * @param vocabularyId the vocabulary ID
2269            * @param start the lower bound of the range of asset categories
2270            * @param end the upper bound of the range of asset categories (not inclusive)
2271            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2272            * @return the ordered range of matching asset categories that the user has permission to view
2273            * @throws SystemException if a system exception occurred
2274            */
2275            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_V(
2276                    long groupId, long parentCategoryId, long vocabularyId, int start,
2277                    int end,
2278                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2279                    throws com.liferay.portal.kernel.exception.SystemException {
2280                    return getPersistence()
2281                                       .filterFindByG_P_V(groupId, parentCategoryId, vocabularyId,
2282                            start, end, orderByComparator);
2283            }
2284    
2285            /**
2286            * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2287            *
2288            * @param categoryId the primary key of the current asset category
2289            * @param groupId the group ID
2290            * @param parentCategoryId the parent category ID
2291            * @param vocabularyId the vocabulary ID
2292            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2293            * @return the previous, current, and next asset category
2294            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
2295            * @throws SystemException if a system exception occurred
2296            */
2297            public static com.liferay.portlet.asset.model.AssetCategory[] filterFindByG_P_V_PrevAndNext(
2298                    long categoryId, long groupId, long parentCategoryId,
2299                    long vocabularyId,
2300                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2301                    throws com.liferay.portal.kernel.exception.SystemException,
2302                            com.liferay.portlet.asset.NoSuchCategoryException {
2303                    return getPersistence()
2304                                       .filterFindByG_P_V_PrevAndNext(categoryId, groupId,
2305                            parentCategoryId, vocabularyId, orderByComparator);
2306            }
2307    
2308            /**
2309            * Removes all the asset categories where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63; from the database.
2310            *
2311            * @param groupId the group ID
2312            * @param parentCategoryId the parent category ID
2313            * @param vocabularyId the vocabulary ID
2314            * @throws SystemException if a system exception occurred
2315            */
2316            public static void removeByG_P_V(long groupId, long parentCategoryId,
2317                    long vocabularyId)
2318                    throws com.liferay.portal.kernel.exception.SystemException {
2319                    getPersistence().removeByG_P_V(groupId, parentCategoryId, vocabularyId);
2320            }
2321    
2322            /**
2323            * Returns the number of asset categories where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2324            *
2325            * @param groupId the group ID
2326            * @param parentCategoryId the parent category ID
2327            * @param vocabularyId the vocabulary ID
2328            * @return the number of matching asset categories
2329            * @throws SystemException if a system exception occurred
2330            */
2331            public static int countByG_P_V(long groupId, long parentCategoryId,
2332                    long vocabularyId)
2333                    throws com.liferay.portal.kernel.exception.SystemException {
2334                    return getPersistence()
2335                                       .countByG_P_V(groupId, parentCategoryId, vocabularyId);
2336            }
2337    
2338            /**
2339            * Returns the number of asset categories that the user has permission to view where groupId = &#63; and parentCategoryId = &#63; and vocabularyId = &#63;.
2340            *
2341            * @param groupId the group ID
2342            * @param parentCategoryId the parent category ID
2343            * @param vocabularyId the vocabulary ID
2344            * @return the number of matching asset categories that the user has permission to view
2345            * @throws SystemException if a system exception occurred
2346            */
2347            public static int filterCountByG_P_V(long groupId, long parentCategoryId,
2348                    long vocabularyId)
2349                    throws com.liferay.portal.kernel.exception.SystemException {
2350                    return getPersistence()
2351                                       .filterCountByG_P_V(groupId, parentCategoryId, vocabularyId);
2352            }
2353    
2354            /**
2355            * Returns all the asset categories where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2356            *
2357            * @param groupId the group ID
2358            * @param name the name
2359            * @param vocabularyId the vocabulary ID
2360            * @return the matching asset categories
2361            * @throws SystemException if a system exception occurred
2362            */
2363            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_LikeN_V(
2364                    long groupId, java.lang.String name, long vocabularyId)
2365                    throws com.liferay.portal.kernel.exception.SystemException {
2366                    return getPersistence().findByG_LikeN_V(groupId, name, vocabularyId);
2367            }
2368    
2369            /**
2370            * Returns a range of all the asset categories where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2371            *
2372            * <p>
2373            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.asset.model.impl.AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2374            * </p>
2375            *
2376            * @param groupId the group ID
2377            * @param name the name
2378            * @param vocabularyId the vocabulary ID
2379            * @param start the lower bound of the range of asset categories
2380            * @param end the upper bound of the range of asset categories (not inclusive)
2381            * @return the range of matching asset categories
2382            * @throws SystemException if a system exception occurred
2383            */
2384            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_LikeN_V(
2385                    long groupId, java.lang.String name, long vocabularyId, int start,
2386                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2387                    return getPersistence()
2388                                       .findByG_LikeN_V(groupId, name, vocabularyId, start, end);
2389            }
2390    
2391            /**
2392            * Returns an ordered range of all the asset categories where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2393            *
2394            * <p>
2395            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2396            * </p>
2397            *
2398            * @param groupId the group ID
2399            * @param name the name
2400            * @param vocabularyId the vocabulary ID
2401            * @param start the lower bound of the range of asset categories
2402            * @param end the upper bound of the range of asset categories (not inclusive)
2403            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2404            * @return the ordered range of matching asset categories
2405            * @throws SystemException if a system exception occurred
2406            */
2407            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_LikeN_V(
2408                    long groupId, java.lang.String name, long vocabularyId, int start,
2409                    int end,
2410                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2411                    throws com.liferay.portal.kernel.exception.SystemException {
2412                    return getPersistence()
2413                                       .findByG_LikeN_V(groupId, name, vocabularyId, start, end,
2414                            orderByComparator);
2415            }
2416    
2417            /**
2418            * Returns the first asset category in the ordered set where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2419            *
2420            * @param groupId the group ID
2421            * @param name the name
2422            * @param vocabularyId the vocabulary ID
2423            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2424            * @return the first matching asset category
2425            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
2426            * @throws SystemException if a system exception occurred
2427            */
2428            public static com.liferay.portlet.asset.model.AssetCategory findByG_LikeN_V_First(
2429                    long groupId, java.lang.String name, long vocabularyId,
2430                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2431                    throws com.liferay.portal.kernel.exception.SystemException,
2432                            com.liferay.portlet.asset.NoSuchCategoryException {
2433                    return getPersistence()
2434                                       .findByG_LikeN_V_First(groupId, name, vocabularyId,
2435                            orderByComparator);
2436            }
2437    
2438            /**
2439            * Returns the first asset category in the ordered set where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2440            *
2441            * @param groupId the group ID
2442            * @param name the name
2443            * @param vocabularyId the vocabulary ID
2444            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2445            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
2446            * @throws SystemException if a system exception occurred
2447            */
2448            public static com.liferay.portlet.asset.model.AssetCategory fetchByG_LikeN_V_First(
2449                    long groupId, java.lang.String name, long vocabularyId,
2450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2451                    throws com.liferay.portal.kernel.exception.SystemException {
2452                    return getPersistence()
2453                                       .fetchByG_LikeN_V_First(groupId, name, vocabularyId,
2454                            orderByComparator);
2455            }
2456    
2457            /**
2458            * Returns the last asset category in the ordered set where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2459            *
2460            * @param groupId the group ID
2461            * @param name the name
2462            * @param vocabularyId the vocabulary ID
2463            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2464            * @return the last matching asset category
2465            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
2466            * @throws SystemException if a system exception occurred
2467            */
2468            public static com.liferay.portlet.asset.model.AssetCategory findByG_LikeN_V_Last(
2469                    long groupId, java.lang.String name, long vocabularyId,
2470                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2471                    throws com.liferay.portal.kernel.exception.SystemException,
2472                            com.liferay.portlet.asset.NoSuchCategoryException {
2473                    return getPersistence()
2474                                       .findByG_LikeN_V_Last(groupId, name, vocabularyId,
2475                            orderByComparator);
2476            }
2477    
2478            /**
2479            * Returns the last asset category in the ordered set where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2480            *
2481            * @param groupId the group ID
2482            * @param name the name
2483            * @param vocabularyId the vocabulary ID
2484            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2485            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
2486            * @throws SystemException if a system exception occurred
2487            */
2488            public static com.liferay.portlet.asset.model.AssetCategory fetchByG_LikeN_V_Last(
2489                    long groupId, java.lang.String name, long vocabularyId,
2490                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2491                    throws com.liferay.portal.kernel.exception.SystemException {
2492                    return getPersistence()
2493                                       .fetchByG_LikeN_V_Last(groupId, name, vocabularyId,
2494                            orderByComparator);
2495            }
2496    
2497            /**
2498            * Returns the asset categories before and after the current asset category in the ordered set where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2499            *
2500            * @param categoryId the primary key of the current asset category
2501            * @param groupId the group ID
2502            * @param name the name
2503            * @param vocabularyId the vocabulary ID
2504            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2505            * @return the previous, current, and next asset category
2506            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
2507            * @throws SystemException if a system exception occurred
2508            */
2509            public static com.liferay.portlet.asset.model.AssetCategory[] findByG_LikeN_V_PrevAndNext(
2510                    long categoryId, long groupId, java.lang.String name,
2511                    long vocabularyId,
2512                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2513                    throws com.liferay.portal.kernel.exception.SystemException,
2514                            com.liferay.portlet.asset.NoSuchCategoryException {
2515                    return getPersistence()
2516                                       .findByG_LikeN_V_PrevAndNext(categoryId, groupId, name,
2517                            vocabularyId, orderByComparator);
2518            }
2519    
2520            /**
2521            * Returns all the asset categories that the user has permission to view where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2522            *
2523            * @param groupId the group ID
2524            * @param name the name
2525            * @param vocabularyId the vocabulary ID
2526            * @return the matching asset categories that the user has permission to view
2527            * @throws SystemException if a system exception occurred
2528            */
2529            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_LikeN_V(
2530                    long groupId, java.lang.String name, long vocabularyId)
2531                    throws com.liferay.portal.kernel.exception.SystemException {
2532                    return getPersistence()
2533                                       .filterFindByG_LikeN_V(groupId, name, vocabularyId);
2534            }
2535    
2536            /**
2537            * Returns a range of all the asset categories that the user has permission to view where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2538            *
2539            * <p>
2540            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2541            * </p>
2542            *
2543            * @param groupId the group ID
2544            * @param name the name
2545            * @param vocabularyId the vocabulary ID
2546            * @param start the lower bound of the range of asset categories
2547            * @param end the upper bound of the range of asset categories (not inclusive)
2548            * @return the range of matching asset categories that the user has permission to view
2549            * @throws SystemException if a system exception occurred
2550            */
2551            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_LikeN_V(
2552                    long groupId, java.lang.String name, long vocabularyId, int start,
2553                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2554                    return getPersistence()
2555                                       .filterFindByG_LikeN_V(groupId, name, vocabularyId, start,
2556                            end);
2557            }
2558    
2559            /**
2560            * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2561            *
2562            * <p>
2563            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2564            * </p>
2565            *
2566            * @param groupId the group ID
2567            * @param name the name
2568            * @param vocabularyId the vocabulary ID
2569            * @param start the lower bound of the range of asset categories
2570            * @param end the upper bound of the range of asset categories (not inclusive)
2571            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2572            * @return the ordered range of matching asset categories that the user has permission to view
2573            * @throws SystemException if a system exception occurred
2574            */
2575            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_LikeN_V(
2576                    long groupId, java.lang.String name, long vocabularyId, int start,
2577                    int end,
2578                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2579                    throws com.liferay.portal.kernel.exception.SystemException {
2580                    return getPersistence()
2581                                       .filterFindByG_LikeN_V(groupId, name, vocabularyId, start,
2582                            end, orderByComparator);
2583            }
2584    
2585            /**
2586            * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2587            *
2588            * @param categoryId the primary key of the current asset category
2589            * @param groupId the group ID
2590            * @param name the name
2591            * @param vocabularyId the vocabulary ID
2592            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2593            * @return the previous, current, and next asset category
2594            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
2595            * @throws SystemException if a system exception occurred
2596            */
2597            public static com.liferay.portlet.asset.model.AssetCategory[] filterFindByG_LikeN_V_PrevAndNext(
2598                    long categoryId, long groupId, java.lang.String name,
2599                    long vocabularyId,
2600                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2601                    throws com.liferay.portal.kernel.exception.SystemException,
2602                            com.liferay.portlet.asset.NoSuchCategoryException {
2603                    return getPersistence()
2604                                       .filterFindByG_LikeN_V_PrevAndNext(categoryId, groupId,
2605                            name, vocabularyId, orderByComparator);
2606            }
2607    
2608            /**
2609            * Returns all the asset categories that the user has permission to view where groupId = &#63; and name LIKE &#63; and vocabularyId = any &#63;.
2610            *
2611            * @param groupId the group ID
2612            * @param name the name
2613            * @param vocabularyIds the vocabulary IDs
2614            * @return the matching asset categories that the user has permission to view
2615            * @throws SystemException if a system exception occurred
2616            */
2617            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_LikeN_V(
2618                    long groupId, java.lang.String name, long[] vocabularyIds)
2619                    throws com.liferay.portal.kernel.exception.SystemException {
2620                    return getPersistence()
2621                                       .filterFindByG_LikeN_V(groupId, name, vocabularyIds);
2622            }
2623    
2624            /**
2625            * Returns a range of all the asset categories that the user has permission to view where groupId = &#63; and name LIKE &#63; and vocabularyId = any &#63;.
2626            *
2627            * <p>
2628            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2629            * </p>
2630            *
2631            * @param groupId the group ID
2632            * @param name the name
2633            * @param vocabularyIds the vocabulary IDs
2634            * @param start the lower bound of the range of asset categories
2635            * @param end the upper bound of the range of asset categories (not inclusive)
2636            * @return the range of matching asset categories that the user has permission to view
2637            * @throws SystemException if a system exception occurred
2638            */
2639            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_LikeN_V(
2640                    long groupId, java.lang.String name, long[] vocabularyIds, int start,
2641                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2642                    return getPersistence()
2643                                       .filterFindByG_LikeN_V(groupId, name, vocabularyIds, start,
2644                            end);
2645            }
2646    
2647            /**
2648            * Returns an ordered range of all the asset categories that the user has permission to view where groupId = &#63; and name LIKE &#63; and vocabularyId = any &#63;.
2649            *
2650            * <p>
2651            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2652            * </p>
2653            *
2654            * @param groupId the group ID
2655            * @param name the name
2656            * @param vocabularyIds the vocabulary IDs
2657            * @param start the lower bound of the range of asset categories
2658            * @param end the upper bound of the range of asset categories (not inclusive)
2659            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2660            * @return the ordered range of matching asset categories that the user has permission to view
2661            * @throws SystemException if a system exception occurred
2662            */
2663            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_LikeN_V(
2664                    long groupId, java.lang.String name, long[] vocabularyIds, int start,
2665                    int end,
2666                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2667                    throws com.liferay.portal.kernel.exception.SystemException {
2668                    return getPersistence()
2669                                       .filterFindByG_LikeN_V(groupId, name, vocabularyIds, start,
2670                            end, orderByComparator);
2671            }
2672    
2673            /**
2674            * Returns all the asset categories where groupId = &#63; and name LIKE &#63; and vocabularyId = any &#63;.
2675            *
2676            * <p>
2677            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2678            * </p>
2679            *
2680            * @param groupId the group ID
2681            * @param name the name
2682            * @param vocabularyIds the vocabulary IDs
2683            * @return the matching asset categories
2684            * @throws SystemException if a system exception occurred
2685            */
2686            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_LikeN_V(
2687                    long groupId, java.lang.String name, long[] vocabularyIds)
2688                    throws com.liferay.portal.kernel.exception.SystemException {
2689                    return getPersistence().findByG_LikeN_V(groupId, name, vocabularyIds);
2690            }
2691    
2692            /**
2693            * Returns a range of all the asset categories where groupId = &#63; and name LIKE &#63; and vocabularyId = any &#63;.
2694            *
2695            * <p>
2696            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2697            * </p>
2698            *
2699            * @param groupId the group ID
2700            * @param name the name
2701            * @param vocabularyIds the vocabulary IDs
2702            * @param start the lower bound of the range of asset categories
2703            * @param end the upper bound of the range of asset categories (not inclusive)
2704            * @return the range of matching asset categories
2705            * @throws SystemException if a system exception occurred
2706            */
2707            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_LikeN_V(
2708                    long groupId, java.lang.String name, long[] vocabularyIds, int start,
2709                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2710                    return getPersistence()
2711                                       .findByG_LikeN_V(groupId, name, vocabularyIds, start, end);
2712            }
2713    
2714            /**
2715            * Returns an ordered range of all the asset categories where groupId = &#63; and name LIKE &#63; and vocabularyId = any &#63;.
2716            *
2717            * <p>
2718            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2719            * </p>
2720            *
2721            * @param groupId the group ID
2722            * @param name the name
2723            * @param vocabularyIds the vocabulary IDs
2724            * @param start the lower bound of the range of asset categories
2725            * @param end the upper bound of the range of asset categories (not inclusive)
2726            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2727            * @return the ordered range of matching asset categories
2728            * @throws SystemException if a system exception occurred
2729            */
2730            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_LikeN_V(
2731                    long groupId, java.lang.String name, long[] vocabularyIds, int start,
2732                    int end,
2733                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2734                    throws com.liferay.portal.kernel.exception.SystemException {
2735                    return getPersistence()
2736                                       .findByG_LikeN_V(groupId, name, vocabularyIds, start, end,
2737                            orderByComparator);
2738            }
2739    
2740            /**
2741            * Removes all the asset categories where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63; from the database.
2742            *
2743            * @param groupId the group ID
2744            * @param name the name
2745            * @param vocabularyId the vocabulary ID
2746            * @throws SystemException if a system exception occurred
2747            */
2748            public static void removeByG_LikeN_V(long groupId, java.lang.String name,
2749                    long vocabularyId)
2750                    throws com.liferay.portal.kernel.exception.SystemException {
2751                    getPersistence().removeByG_LikeN_V(groupId, name, vocabularyId);
2752            }
2753    
2754            /**
2755            * Returns the number of asset categories where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2756            *
2757            * @param groupId the group ID
2758            * @param name the name
2759            * @param vocabularyId the vocabulary ID
2760            * @return the number of matching asset categories
2761            * @throws SystemException if a system exception occurred
2762            */
2763            public static int countByG_LikeN_V(long groupId, java.lang.String name,
2764                    long vocabularyId)
2765                    throws com.liferay.portal.kernel.exception.SystemException {
2766                    return getPersistence().countByG_LikeN_V(groupId, name, vocabularyId);
2767            }
2768    
2769            /**
2770            * Returns the number of asset categories where groupId = &#63; and name LIKE &#63; and vocabularyId = any &#63;.
2771            *
2772            * @param groupId the group ID
2773            * @param name the name
2774            * @param vocabularyIds the vocabulary IDs
2775            * @return the number of matching asset categories
2776            * @throws SystemException if a system exception occurred
2777            */
2778            public static int countByG_LikeN_V(long groupId, java.lang.String name,
2779                    long[] vocabularyIds)
2780                    throws com.liferay.portal.kernel.exception.SystemException {
2781                    return getPersistence().countByG_LikeN_V(groupId, name, vocabularyIds);
2782            }
2783    
2784            /**
2785            * Returns the number of asset categories that the user has permission to view where groupId = &#63; and name LIKE &#63; and vocabularyId = &#63;.
2786            *
2787            * @param groupId the group ID
2788            * @param name the name
2789            * @param vocabularyId the vocabulary ID
2790            * @return the number of matching asset categories that the user has permission to view
2791            * @throws SystemException if a system exception occurred
2792            */
2793            public static int filterCountByG_LikeN_V(long groupId,
2794                    java.lang.String name, long vocabularyId)
2795                    throws com.liferay.portal.kernel.exception.SystemException {
2796                    return getPersistence()
2797                                       .filterCountByG_LikeN_V(groupId, name, vocabularyId);
2798            }
2799    
2800            /**
2801            * Returns the number of asset categories that the user has permission to view where groupId = &#63; and name LIKE &#63; and vocabularyId = any &#63;.
2802            *
2803            * @param groupId the group ID
2804            * @param name the name
2805            * @param vocabularyIds the vocabulary IDs
2806            * @return the number of matching asset categories that the user has permission to view
2807            * @throws SystemException if a system exception occurred
2808            */
2809            public static int filterCountByG_LikeN_V(long groupId,
2810                    java.lang.String name, long[] vocabularyIds)
2811                    throws com.liferay.portal.kernel.exception.SystemException {
2812                    return getPersistence()
2813                                       .filterCountByG_LikeN_V(groupId, name, vocabularyIds);
2814            }
2815    
2816            /**
2817            * Returns the asset category where parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63; or throws a {@link com.liferay.portlet.asset.NoSuchCategoryException} if it could not be found.
2818            *
2819            * @param parentCategoryId the parent category ID
2820            * @param name the name
2821            * @param vocabularyId the vocabulary ID
2822            * @return the matching asset category
2823            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
2824            * @throws SystemException if a system exception occurred
2825            */
2826            public static com.liferay.portlet.asset.model.AssetCategory findByP_N_V(
2827                    long parentCategoryId, java.lang.String name, long vocabularyId)
2828                    throws com.liferay.portal.kernel.exception.SystemException,
2829                            com.liferay.portlet.asset.NoSuchCategoryException {
2830                    return getPersistence().findByP_N_V(parentCategoryId, name, vocabularyId);
2831            }
2832    
2833            /**
2834            * Returns the asset category where parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
2835            *
2836            * @param parentCategoryId the parent category ID
2837            * @param name the name
2838            * @param vocabularyId the vocabulary ID
2839            * @return the matching asset category, or <code>null</code> if a matching asset category could not be found
2840            * @throws SystemException if a system exception occurred
2841            */
2842            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_V(
2843                    long parentCategoryId, java.lang.String name, long vocabularyId)
2844                    throws com.liferay.portal.kernel.exception.SystemException {
2845                    return getPersistence()
2846                                       .fetchByP_N_V(parentCategoryId, name, vocabularyId);
2847            }
2848    
2849            /**
2850            * Returns the asset category where parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
2851            *
2852            * @param parentCategoryId the parent category ID
2853            * @param name the name
2854            * @param vocabularyId the vocabulary ID
2855            * @param retrieveFromCache whether to use the finder cache
2856            * @return the matching asset category, or <code>null</code> if a matching asset category could not be found
2857            * @throws SystemException if a system exception occurred
2858            */
2859            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_V(
2860                    long parentCategoryId, java.lang.String name, long vocabularyId,
2861                    boolean retrieveFromCache)
2862                    throws com.liferay.portal.kernel.exception.SystemException {
2863                    return getPersistence()
2864                                       .fetchByP_N_V(parentCategoryId, name, vocabularyId,
2865                            retrieveFromCache);
2866            }
2867    
2868            /**
2869            * Removes the asset category where parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63; from the database.
2870            *
2871            * @param parentCategoryId the parent category ID
2872            * @param name the name
2873            * @param vocabularyId the vocabulary ID
2874            * @return the asset category that was removed
2875            * @throws SystemException if a system exception occurred
2876            */
2877            public static com.liferay.portlet.asset.model.AssetCategory removeByP_N_V(
2878                    long parentCategoryId, java.lang.String name, long vocabularyId)
2879                    throws com.liferay.portal.kernel.exception.SystemException,
2880                            com.liferay.portlet.asset.NoSuchCategoryException {
2881                    return getPersistence()
2882                                       .removeByP_N_V(parentCategoryId, name, vocabularyId);
2883            }
2884    
2885            /**
2886            * Returns the number of asset categories where parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2887            *
2888            * @param parentCategoryId the parent category ID
2889            * @param name the name
2890            * @param vocabularyId the vocabulary ID
2891            * @return the number of matching asset categories
2892            * @throws SystemException if a system exception occurred
2893            */
2894            public static int countByP_N_V(long parentCategoryId,
2895                    java.lang.String name, long vocabularyId)
2896                    throws com.liferay.portal.kernel.exception.SystemException {
2897                    return getPersistence()
2898                                       .countByP_N_V(parentCategoryId, name, vocabularyId);
2899            }
2900    
2901            /**
2902            * Returns all the asset categories where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2903            *
2904            * @param groupId the group ID
2905            * @param parentCategoryId the parent category ID
2906            * @param name the name
2907            * @param vocabularyId the vocabulary ID
2908            * @return the matching asset categories
2909            * @throws SystemException if a system exception occurred
2910            */
2911            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_N_V(
2912                    long groupId, long parentCategoryId, java.lang.String name,
2913                    long vocabularyId)
2914                    throws com.liferay.portal.kernel.exception.SystemException {
2915                    return getPersistence()
2916                                       .findByG_P_N_V(groupId, parentCategoryId, name, vocabularyId);
2917            }
2918    
2919            /**
2920            * Returns a range of all the asset categories where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2921            *
2922            * <p>
2923            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2924            * </p>
2925            *
2926            * @param groupId the group ID
2927            * @param parentCategoryId the parent category ID
2928            * @param name the name
2929            * @param vocabularyId the vocabulary ID
2930            * @param start the lower bound of the range of asset categories
2931            * @param end the upper bound of the range of asset categories (not inclusive)
2932            * @return the range of matching asset categories
2933            * @throws SystemException if a system exception occurred
2934            */
2935            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_N_V(
2936                    long groupId, long parentCategoryId, java.lang.String name,
2937                    long vocabularyId, int start, int end)
2938                    throws com.liferay.portal.kernel.exception.SystemException {
2939                    return getPersistence()
2940                                       .findByG_P_N_V(groupId, parentCategoryId, name,
2941                            vocabularyId, start, end);
2942            }
2943    
2944            /**
2945            * Returns an ordered range of all the asset categories where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2946            *
2947            * <p>
2948            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
2949            * </p>
2950            *
2951            * @param groupId the group ID
2952            * @param parentCategoryId the parent category ID
2953            * @param name the name
2954            * @param vocabularyId the vocabulary ID
2955            * @param start the lower bound of the range of asset categories
2956            * @param end the upper bound of the range of asset categories (not inclusive)
2957            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2958            * @return the ordered range of matching asset categories
2959            * @throws SystemException if a system exception occurred
2960            */
2961            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_N_V(
2962                    long groupId, long parentCategoryId, java.lang.String name,
2963                    long vocabularyId, int start, int end,
2964                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2965                    throws com.liferay.portal.kernel.exception.SystemException {
2966                    return getPersistence()
2967                                       .findByG_P_N_V(groupId, parentCategoryId, name,
2968                            vocabularyId, start, end, orderByComparator);
2969            }
2970    
2971            /**
2972            * Returns the first asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2973            *
2974            * @param groupId the group ID
2975            * @param parentCategoryId the parent category ID
2976            * @param name the name
2977            * @param vocabularyId the vocabulary ID
2978            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2979            * @return the first matching asset category
2980            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
2981            * @throws SystemException if a system exception occurred
2982            */
2983            public static com.liferay.portlet.asset.model.AssetCategory findByG_P_N_V_First(
2984                    long groupId, long parentCategoryId, java.lang.String name,
2985                    long vocabularyId,
2986                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2987                    throws com.liferay.portal.kernel.exception.SystemException,
2988                            com.liferay.portlet.asset.NoSuchCategoryException {
2989                    return getPersistence()
2990                                       .findByG_P_N_V_First(groupId, parentCategoryId, name,
2991                            vocabularyId, orderByComparator);
2992            }
2993    
2994            /**
2995            * Returns the first asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2996            *
2997            * @param groupId the group ID
2998            * @param parentCategoryId the parent category ID
2999            * @param name the name
3000            * @param vocabularyId the vocabulary ID
3001            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3002            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
3003            * @throws SystemException if a system exception occurred
3004            */
3005            public static com.liferay.portlet.asset.model.AssetCategory fetchByG_P_N_V_First(
3006                    long groupId, long parentCategoryId, java.lang.String name,
3007                    long vocabularyId,
3008                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3009                    throws com.liferay.portal.kernel.exception.SystemException {
3010                    return getPersistence()
3011                                       .fetchByG_P_N_V_First(groupId, parentCategoryId, name,
3012                            vocabularyId, orderByComparator);
3013            }
3014    
3015            /**
3016            * Returns the last asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
3017            *
3018            * @param groupId the group ID
3019            * @param parentCategoryId the parent category ID
3020            * @param name the name
3021            * @param vocabularyId the vocabulary ID
3022            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3023            * @return the last matching asset category
3024            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
3025            * @throws SystemException if a system exception occurred
3026            */
3027            public static com.liferay.portlet.asset.model.AssetCategory findByG_P_N_V_Last(
3028                    long groupId, long parentCategoryId, java.lang.String name,
3029                    long vocabularyId,
3030                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3031                    throws com.liferay.portal.kernel.exception.SystemException,
3032                            com.liferay.portlet.asset.NoSuchCategoryException {
3033                    return getPersistence()
3034                                       .findByG_P_N_V_Last(groupId, parentCategoryId, name,
3035                            vocabularyId, orderByComparator);
3036            }
3037    
3038            /**
3039            * Returns the last asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
3040            *
3041            * @param groupId the group ID
3042            * @param parentCategoryId the parent category ID
3043            * @param name the name
3044            * @param vocabularyId the vocabulary ID
3045            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3046            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
3047            * @throws SystemException if a system exception occurred
3048            */
3049            public static com.liferay.portlet.asset.model.AssetCategory fetchByG_P_N_V_Last(
3050                    long groupId, long parentCategoryId, java.lang.String name,
3051                    long vocabularyId,
3052                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3053                    throws com.liferay.portal.kernel.exception.SystemException {
3054                    return getPersistence()
3055                                       .fetchByG_P_N_V_Last(groupId, parentCategoryId, name,
3056                            vocabularyId, orderByComparator);
3057            }
3058    
3059            /**
3060            * Returns the asset categories before and after the current asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
3061            *
3062            * @param categoryId the primary key of the current asset category
3063            * @param groupId the group ID
3064            * @param parentCategoryId the parent category ID
3065            * @param name the name
3066            * @param vocabularyId the vocabulary ID
3067            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3068            * @return the previous, current, and next asset category
3069            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
3070            * @throws SystemException if a system exception occurred
3071            */
3072            public static com.liferay.portlet.asset.model.AssetCategory[] findByG_P_N_V_PrevAndNext(
3073                    long categoryId, long groupId, long parentCategoryId,
3074                    java.lang.String name, long vocabularyId,
3075                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3076                    throws com.liferay.portal.kernel.exception.SystemException,
3077                            com.liferay.portlet.asset.NoSuchCategoryException {
3078                    return getPersistence()
3079                                       .findByG_P_N_V_PrevAndNext(categoryId, groupId,
3080                            parentCategoryId, name, vocabularyId, orderByComparator);
3081            }
3082    
3083            /**
3084            * Returns all the asset categories that the user has permission to view where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
3085            *
3086            * @param groupId the group ID
3087            * @param parentCategoryId the parent category ID
3088            * @param name the name
3089            * @param vocabularyId the vocabulary ID
3090            * @return the matching asset categories that the user has permission to view
3091            * @throws SystemException if a system exception occurred
3092            */
3093            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_N_V(
3094                    long groupId, long parentCategoryId, java.lang.String name,
3095                    long vocabularyId)
3096                    throws com.liferay.portal.kernel.exception.SystemException {
3097                    return getPersistence()
3098                                       .filterFindByG_P_N_V(groupId, parentCategoryId, name,
3099                            vocabularyId);
3100            }
3101    
3102            /**
3103            * Returns a range of all the asset categories that the user has permission to view where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
3104            *
3105            * <p>
3106            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
3107            * </p>
3108            *
3109            * @param groupId the group ID
3110            * @param parentCategoryId the parent category ID
3111            * @param name the name
3112            * @param vocabularyId the vocabulary ID
3113            * @param start the lower bound of the range of asset categories
3114            * @param end the upper bound of the range of asset categories (not inclusive)
3115            * @return the range of matching asset categories that the user has permission to view
3116            * @throws SystemException if a system exception occurred
3117            */
3118            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_N_V(
3119                    long groupId, long parentCategoryId, java.lang.String name,
3120                    long vocabularyId, int start, int end)
3121                    throws com.liferay.portal.kernel.exception.SystemException {
3122                    return getPersistence()
3123                                       .filterFindByG_P_N_V(groupId, parentCategoryId, name,
3124                            vocabularyId, start, end);
3125            }
3126    
3127            /**
3128            * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
3129            *
3130            * <p>
3131            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
3132            * </p>
3133            *
3134            * @param groupId the group ID
3135            * @param parentCategoryId the parent category ID
3136            * @param name the name
3137            * @param vocabularyId the vocabulary ID
3138            * @param start the lower bound of the range of asset categories
3139            * @param end the upper bound of the range of asset categories (not inclusive)
3140            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3141            * @return the ordered range of matching asset categories that the user has permission to view
3142            * @throws SystemException if a system exception occurred
3143            */
3144            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_N_V(
3145                    long groupId, long parentCategoryId, java.lang.String name,
3146                    long vocabularyId, int start, int end,
3147                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3148                    throws com.liferay.portal.kernel.exception.SystemException {
3149                    return getPersistence()
3150                                       .filterFindByG_P_N_V(groupId, parentCategoryId, name,
3151                            vocabularyId, start, end, orderByComparator);
3152            }
3153    
3154            /**
3155            * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
3156            *
3157            * @param categoryId the primary key of the current asset category
3158            * @param groupId the group ID
3159            * @param parentCategoryId the parent category ID
3160            * @param name the name
3161            * @param vocabularyId the vocabulary ID
3162            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3163            * @return the previous, current, and next asset category
3164            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
3165            * @throws SystemException if a system exception occurred
3166            */
3167            public static com.liferay.portlet.asset.model.AssetCategory[] filterFindByG_P_N_V_PrevAndNext(
3168                    long categoryId, long groupId, long parentCategoryId,
3169                    java.lang.String name, long vocabularyId,
3170                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3171                    throws com.liferay.portal.kernel.exception.SystemException,
3172                            com.liferay.portlet.asset.NoSuchCategoryException {
3173                    return getPersistence()
3174                                       .filterFindByG_P_N_V_PrevAndNext(categoryId, groupId,
3175                            parentCategoryId, name, vocabularyId, orderByComparator);
3176            }
3177    
3178            /**
3179            * Removes all the asset categories where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63; from the database.
3180            *
3181            * @param groupId the group ID
3182            * @param parentCategoryId the parent category ID
3183            * @param name the name
3184            * @param vocabularyId the vocabulary ID
3185            * @throws SystemException if a system exception occurred
3186            */
3187            public static void removeByG_P_N_V(long groupId, long parentCategoryId,
3188                    java.lang.String name, long vocabularyId)
3189                    throws com.liferay.portal.kernel.exception.SystemException {
3190                    getPersistence()
3191                            .removeByG_P_N_V(groupId, parentCategoryId, name, vocabularyId);
3192            }
3193    
3194            /**
3195            * Returns the number of asset categories where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
3196            *
3197            * @param groupId the group ID
3198            * @param parentCategoryId the parent category ID
3199            * @param name the name
3200            * @param vocabularyId the vocabulary ID
3201            * @return the number of matching asset categories
3202            * @throws SystemException if a system exception occurred
3203            */
3204            public static int countByG_P_N_V(long groupId, long parentCategoryId,
3205                    java.lang.String name, long vocabularyId)
3206                    throws com.liferay.portal.kernel.exception.SystemException {
3207                    return getPersistence()
3208                                       .countByG_P_N_V(groupId, parentCategoryId, name, vocabularyId);
3209            }
3210    
3211            /**
3212            * Returns the number of asset categories that the user has permission to view where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
3213            *
3214            * @param groupId the group ID
3215            * @param parentCategoryId the parent category ID
3216            * @param name the name
3217            * @param vocabularyId the vocabulary ID
3218            * @return the number of matching asset categories that the user has permission to view
3219            * @throws SystemException if a system exception occurred
3220            */
3221            public static int filterCountByG_P_N_V(long groupId, long parentCategoryId,
3222                    java.lang.String name, long vocabularyId)
3223                    throws com.liferay.portal.kernel.exception.SystemException {
3224                    return getPersistence()
3225                                       .filterCountByG_P_N_V(groupId, parentCategoryId, name,
3226                            vocabularyId);
3227            }
3228    
3229            /**
3230            * Caches the asset category in the entity cache if it is enabled.
3231            *
3232            * @param assetCategory the asset category
3233            */
3234            public static void cacheResult(
3235                    com.liferay.portlet.asset.model.AssetCategory assetCategory) {
3236                    getPersistence().cacheResult(assetCategory);
3237            }
3238    
3239            /**
3240            * Caches the asset categories in the entity cache if it is enabled.
3241            *
3242            * @param assetCategories the asset categories
3243            */
3244            public static void cacheResult(
3245                    java.util.List<com.liferay.portlet.asset.model.AssetCategory> assetCategories) {
3246                    getPersistence().cacheResult(assetCategories);
3247            }
3248    
3249            /**
3250            * Creates a new asset category with the primary key. Does not add the asset category to the database.
3251            *
3252            * @param categoryId the primary key for the new asset category
3253            * @return the new asset category
3254            */
3255            public static com.liferay.portlet.asset.model.AssetCategory create(
3256                    long categoryId) {
3257                    return getPersistence().create(categoryId);
3258            }
3259    
3260            /**
3261            * Removes the asset category with the primary key from the database. Also notifies the appropriate model listeners.
3262            *
3263            * @param categoryId the primary key of the asset category
3264            * @return the asset category that was removed
3265            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
3266            * @throws SystemException if a system exception occurred
3267            */
3268            public static com.liferay.portlet.asset.model.AssetCategory remove(
3269                    long categoryId)
3270                    throws com.liferay.portal.kernel.exception.SystemException,
3271                            com.liferay.portlet.asset.NoSuchCategoryException {
3272                    return getPersistence().remove(categoryId);
3273            }
3274    
3275            public static com.liferay.portlet.asset.model.AssetCategory updateImpl(
3276                    com.liferay.portlet.asset.model.AssetCategory assetCategory)
3277                    throws com.liferay.portal.kernel.exception.SystemException {
3278                    return getPersistence().updateImpl(assetCategory);
3279            }
3280    
3281            /**
3282            * Returns the asset category with the primary key or throws a {@link com.liferay.portlet.asset.NoSuchCategoryException} if it could not be found.
3283            *
3284            * @param categoryId the primary key of the asset category
3285            * @return the asset category
3286            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
3287            * @throws SystemException if a system exception occurred
3288            */
3289            public static com.liferay.portlet.asset.model.AssetCategory findByPrimaryKey(
3290                    long categoryId)
3291                    throws com.liferay.portal.kernel.exception.SystemException,
3292                            com.liferay.portlet.asset.NoSuchCategoryException {
3293                    return getPersistence().findByPrimaryKey(categoryId);
3294            }
3295    
3296            /**
3297            * Returns the asset category with the primary key or returns <code>null</code> if it could not be found.
3298            *
3299            * @param categoryId the primary key of the asset category
3300            * @return the asset category, or <code>null</code> if a asset category with the primary key could not be found
3301            * @throws SystemException if a system exception occurred
3302            */
3303            public static com.liferay.portlet.asset.model.AssetCategory fetchByPrimaryKey(
3304                    long categoryId)
3305                    throws com.liferay.portal.kernel.exception.SystemException {
3306                    return getPersistence().fetchByPrimaryKey(categoryId);
3307            }
3308    
3309            /**
3310            * Returns all the asset categories.
3311            *
3312            * @return the asset categories
3313            * @throws SystemException if a system exception occurred
3314            */
3315            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findAll()
3316                    throws com.liferay.portal.kernel.exception.SystemException {
3317                    return getPersistence().findAll();
3318            }
3319    
3320            /**
3321            * Returns a range of all the asset categories.
3322            *
3323            * <p>
3324            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
3325            * </p>
3326            *
3327            * @param start the lower bound of the range of asset categories
3328            * @param end the upper bound of the range of asset categories (not inclusive)
3329            * @return the range of asset categories
3330            * @throws SystemException if a system exception occurred
3331            */
3332            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findAll(
3333                    int start, int end)
3334                    throws com.liferay.portal.kernel.exception.SystemException {
3335                    return getPersistence().findAll(start, end);
3336            }
3337    
3338            /**
3339            * Returns an ordered range of all the asset categories.
3340            *
3341            * <p>
3342            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
3343            * </p>
3344            *
3345            * @param start the lower bound of the range of asset categories
3346            * @param end the upper bound of the range of asset categories (not inclusive)
3347            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3348            * @return the ordered range of asset categories
3349            * @throws SystemException if a system exception occurred
3350            */
3351            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findAll(
3352                    int start, int end,
3353                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3354                    throws com.liferay.portal.kernel.exception.SystemException {
3355                    return getPersistence().findAll(start, end, orderByComparator);
3356            }
3357    
3358            /**
3359            * Removes all the asset categories from the database.
3360            *
3361            * @throws SystemException if a system exception occurred
3362            */
3363            public static void removeAll()
3364                    throws com.liferay.portal.kernel.exception.SystemException {
3365                    getPersistence().removeAll();
3366            }
3367    
3368            /**
3369            * Returns the number of asset categories.
3370            *
3371            * @return the number of asset categories
3372            * @throws SystemException if a system exception occurred
3373            */
3374            public static int countAll()
3375                    throws com.liferay.portal.kernel.exception.SystemException {
3376                    return getPersistence().countAll();
3377            }
3378    
3379            /**
3380            * Returns all the asset entries associated with the asset category.
3381            *
3382            * @param pk the primary key of the asset category
3383            * @return the asset entries associated with the asset category
3384            * @throws SystemException if a system exception occurred
3385            */
3386            public static java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
3387                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
3388                    return getPersistence().getAssetEntries(pk);
3389            }
3390    
3391            /**
3392            * Returns a range of all the asset entries associated with the asset category.
3393            *
3394            * <p>
3395            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
3396            * </p>
3397            *
3398            * @param pk the primary key of the asset category
3399            * @param start the lower bound of the range of asset categories
3400            * @param end the upper bound of the range of asset categories (not inclusive)
3401            * @return the range of asset entries associated with the asset category
3402            * @throws SystemException if a system exception occurred
3403            */
3404            public static java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
3405                    long pk, int start, int end)
3406                    throws com.liferay.portal.kernel.exception.SystemException {
3407                    return getPersistence().getAssetEntries(pk, start, end);
3408            }
3409    
3410            /**
3411            * Returns an ordered range of all the asset entries associated with the asset category.
3412            *
3413            * <p>
3414            * 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.asset.model.impl.AssetCategoryModelImpl}. 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.
3415            * </p>
3416            *
3417            * @param pk the primary key of the asset category
3418            * @param start the lower bound of the range of asset categories
3419            * @param end the upper bound of the range of asset categories (not inclusive)
3420            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3421            * @return the ordered range of asset entries associated with the asset category
3422            * @throws SystemException if a system exception occurred
3423            */
3424            public static java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
3425                    long pk, int start, int end,
3426                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3427                    throws com.liferay.portal.kernel.exception.SystemException {
3428                    return getPersistence()
3429                                       .getAssetEntries(pk, start, end, orderByComparator);
3430            }
3431    
3432            /**
3433            * Returns the number of asset entries associated with the asset category.
3434            *
3435            * @param pk the primary key of the asset category
3436            * @return the number of asset entries associated with the asset category
3437            * @throws SystemException if a system exception occurred
3438            */
3439            public static int getAssetEntriesSize(long pk)
3440                    throws com.liferay.portal.kernel.exception.SystemException {
3441                    return getPersistence().getAssetEntriesSize(pk);
3442            }
3443    
3444            /**
3445            * Returns <code>true</code> if the asset entry is associated with the asset category.
3446            *
3447            * @param pk the primary key of the asset category
3448            * @param assetEntryPK the primary key of the asset entry
3449            * @return <code>true</code> if the asset entry is associated with the asset category; <code>false</code> otherwise
3450            * @throws SystemException if a system exception occurred
3451            */
3452            public static boolean containsAssetEntry(long pk, long assetEntryPK)
3453                    throws com.liferay.portal.kernel.exception.SystemException {
3454                    return getPersistence().containsAssetEntry(pk, assetEntryPK);
3455            }
3456    
3457            /**
3458            * Returns <code>true</code> if the asset category has any asset entries associated with it.
3459            *
3460            * @param pk the primary key of the asset category to check for associations with asset entries
3461            * @return <code>true</code> if the asset category has any asset entries associated with it; <code>false</code> otherwise
3462            * @throws SystemException if a system exception occurred
3463            */
3464            public static boolean containsAssetEntries(long pk)
3465                    throws com.liferay.portal.kernel.exception.SystemException {
3466                    return getPersistence().containsAssetEntries(pk);
3467            }
3468    
3469            /**
3470            * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3471            *
3472            * @param pk the primary key of the asset category
3473            * @param assetEntryPK the primary key of the asset entry
3474            * @throws SystemException if a system exception occurred
3475            */
3476            public static void addAssetEntry(long pk, long assetEntryPK)
3477                    throws com.liferay.portal.kernel.exception.SystemException {
3478                    getPersistence().addAssetEntry(pk, assetEntryPK);
3479            }
3480    
3481            /**
3482            * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3483            *
3484            * @param pk the primary key of the asset category
3485            * @param assetEntry the asset entry
3486            * @throws SystemException if a system exception occurred
3487            */
3488            public static void addAssetEntry(long pk,
3489                    com.liferay.portlet.asset.model.AssetEntry assetEntry)
3490                    throws com.liferay.portal.kernel.exception.SystemException {
3491                    getPersistence().addAssetEntry(pk, assetEntry);
3492            }
3493    
3494            /**
3495            * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3496            *
3497            * @param pk the primary key of the asset category
3498            * @param assetEntryPKs the primary keys of the asset entries
3499            * @throws SystemException if a system exception occurred
3500            */
3501            public static void addAssetEntries(long pk, long[] assetEntryPKs)
3502                    throws com.liferay.portal.kernel.exception.SystemException {
3503                    getPersistence().addAssetEntries(pk, assetEntryPKs);
3504            }
3505    
3506            /**
3507            * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3508            *
3509            * @param pk the primary key of the asset category
3510            * @param assetEntries the asset entries
3511            * @throws SystemException if a system exception occurred
3512            */
3513            public static void addAssetEntries(long pk,
3514                    java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries)
3515                    throws com.liferay.portal.kernel.exception.SystemException {
3516                    getPersistence().addAssetEntries(pk, assetEntries);
3517            }
3518    
3519            /**
3520            * Clears all associations between the asset category and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3521            *
3522            * @param pk the primary key of the asset category to clear the associated asset entries from
3523            * @throws SystemException if a system exception occurred
3524            */
3525            public static void clearAssetEntries(long pk)
3526                    throws com.liferay.portal.kernel.exception.SystemException {
3527                    getPersistence().clearAssetEntries(pk);
3528            }
3529    
3530            /**
3531            * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3532            *
3533            * @param pk the primary key of the asset category
3534            * @param assetEntryPK the primary key of the asset entry
3535            * @throws SystemException if a system exception occurred
3536            */
3537            public static void removeAssetEntry(long pk, long assetEntryPK)
3538                    throws com.liferay.portal.kernel.exception.SystemException {
3539                    getPersistence().removeAssetEntry(pk, assetEntryPK);
3540            }
3541    
3542            /**
3543            * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3544            *
3545            * @param pk the primary key of the asset category
3546            * @param assetEntry the asset entry
3547            * @throws SystemException if a system exception occurred
3548            */
3549            public static void removeAssetEntry(long pk,
3550                    com.liferay.portlet.asset.model.AssetEntry assetEntry)
3551                    throws com.liferay.portal.kernel.exception.SystemException {
3552                    getPersistence().removeAssetEntry(pk, assetEntry);
3553            }
3554    
3555            /**
3556            * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3557            *
3558            * @param pk the primary key of the asset category
3559            * @param assetEntryPKs the primary keys of the asset entries
3560            * @throws SystemException if a system exception occurred
3561            */
3562            public static void removeAssetEntries(long pk, long[] assetEntryPKs)
3563                    throws com.liferay.portal.kernel.exception.SystemException {
3564                    getPersistence().removeAssetEntries(pk, assetEntryPKs);
3565            }
3566    
3567            /**
3568            * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3569            *
3570            * @param pk the primary key of the asset category
3571            * @param assetEntries the asset entries
3572            * @throws SystemException if a system exception occurred
3573            */
3574            public static void removeAssetEntries(long pk,
3575                    java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries)
3576                    throws com.liferay.portal.kernel.exception.SystemException {
3577                    getPersistence().removeAssetEntries(pk, assetEntries);
3578            }
3579    
3580            /**
3581            * Sets the asset entries associated with the asset category, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3582            *
3583            * @param pk the primary key of the asset category
3584            * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset category
3585            * @throws SystemException if a system exception occurred
3586            */
3587            public static void setAssetEntries(long pk, long[] assetEntryPKs)
3588                    throws com.liferay.portal.kernel.exception.SystemException {
3589                    getPersistence().setAssetEntries(pk, assetEntryPKs);
3590            }
3591    
3592            /**
3593            * Sets the asset entries associated with the asset category, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3594            *
3595            * @param pk the primary key of the asset category
3596            * @param assetEntries the asset entries to be associated with the asset category
3597            * @throws SystemException if a system exception occurred
3598            */
3599            public static void setAssetEntries(long pk,
3600                    java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries)
3601                    throws com.liferay.portal.kernel.exception.SystemException {
3602                    getPersistence().setAssetEntries(pk, assetEntries);
3603            }
3604    
3605            /**
3606            * Rebuilds the asset categories tree for the scope using the modified pre-order tree traversal algorithm.
3607            *
3608            * <p>
3609            * Only call this method if the tree has become stale through operations other than normal CRUD. Under normal circumstances the tree is automatically rebuilt whenver necessary.
3610            * </p>
3611            *
3612            * @param groupId the ID of the scope
3613            * @param force whether to force the rebuild even if the tree is not stale
3614            */
3615            public static void rebuildTree(long groupId, boolean force)
3616                    throws com.liferay.portal.kernel.exception.SystemException {
3617                    getPersistence().rebuildTree(groupId, force);
3618            }
3619    
3620            public static void setRebuildTreeEnabled(boolean rebuildTreeEnabled) {
3621                    getPersistence().setRebuildTreeEnabled(rebuildTreeEnabled);
3622            }
3623    
3624            public static AssetCategoryPersistence getPersistence() {
3625                    if (_persistence == null) {
3626                            _persistence = (AssetCategoryPersistence)PortalBeanLocatorUtil.locate(AssetCategoryPersistence.class.getName());
3627    
3628                            ReferenceRegistry.registerReference(AssetCategoryUtil.class,
3629                                    "_persistence");
3630                    }
3631    
3632                    return _persistence;
3633            }
3634    
3635            /**
3636             * @deprecated As of 6.2.0
3637             */
3638            public void setPersistence(AssetCategoryPersistence persistence) {
3639            }
3640    
3641            private static AssetCategoryPersistence _persistence;
3642    }