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