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