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