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