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