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