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            * Removes all the asset categories where groupId = &#63; and vocabularyId = &#63; from the database.
1337            *
1338            * @param groupId the group ID
1339            * @param vocabularyId the vocabulary ID
1340            * @throws SystemException if a system exception occurred
1341            */
1342            public static void removeByG_V(long groupId, long vocabularyId)
1343                    throws com.liferay.portal.kernel.exception.SystemException {
1344                    getPersistence().removeByG_V(groupId, vocabularyId);
1345            }
1346    
1347            /**
1348            * Returns the number of asset categories where groupId = &#63; and vocabularyId = &#63;.
1349            *
1350            * @param groupId the group ID
1351            * @param vocabularyId the vocabulary ID
1352            * @return the number of matching asset categories
1353            * @throws SystemException if a system exception occurred
1354            */
1355            public static int countByG_V(long groupId, long vocabularyId)
1356                    throws com.liferay.portal.kernel.exception.SystemException {
1357                    return getPersistence().countByG_V(groupId, vocabularyId);
1358            }
1359    
1360            /**
1361            * Returns the number of asset categories that the user has permission to view where groupId = &#63; and vocabularyId = &#63;.
1362            *
1363            * @param groupId the group ID
1364            * @param vocabularyId the vocabulary ID
1365            * @return the number of matching asset categories that the user has permission to view
1366            * @throws SystemException if a system exception occurred
1367            */
1368            public static int filterCountByG_V(long groupId, long vocabularyId)
1369                    throws com.liferay.portal.kernel.exception.SystemException {
1370                    return getPersistence().filterCountByG_V(groupId, vocabularyId);
1371            }
1372    
1373            /**
1374            * Returns all the asset categories where parentCategoryId = &#63; and name = &#63;.
1375            *
1376            * @param parentCategoryId the parent category ID
1377            * @param name the name
1378            * @return the matching asset categories
1379            * @throws SystemException if a system exception occurred
1380            */
1381            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_N(
1382                    long parentCategoryId, java.lang.String name)
1383                    throws com.liferay.portal.kernel.exception.SystemException {
1384                    return getPersistence().findByP_N(parentCategoryId, name);
1385            }
1386    
1387            /**
1388            * Returns a range of all the asset categories where parentCategoryId = &#63; and name = &#63;.
1389            *
1390            * <p>
1391            * 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.
1392            * </p>
1393            *
1394            * @param parentCategoryId the parent category ID
1395            * @param name the name
1396            * @param start the lower bound of the range of asset categories
1397            * @param end the upper bound of the range of asset categories (not inclusive)
1398            * @return the range of matching asset categories
1399            * @throws SystemException if a system exception occurred
1400            */
1401            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_N(
1402                    long parentCategoryId, java.lang.String name, int start, int end)
1403                    throws com.liferay.portal.kernel.exception.SystemException {
1404                    return getPersistence().findByP_N(parentCategoryId, name, start, end);
1405            }
1406    
1407            /**
1408            * Returns an ordered range of all the asset categories where parentCategoryId = &#63; and name = &#63;.
1409            *
1410            * <p>
1411            * 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.
1412            * </p>
1413            *
1414            * @param parentCategoryId the parent category ID
1415            * @param name the name
1416            * @param start the lower bound of the range of asset categories
1417            * @param end the upper bound of the range of asset categories (not inclusive)
1418            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1419            * @return the ordered range of matching asset categories
1420            * @throws SystemException if a system exception occurred
1421            */
1422            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_N(
1423                    long parentCategoryId, java.lang.String name, int start, int end,
1424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1425                    throws com.liferay.portal.kernel.exception.SystemException {
1426                    return getPersistence()
1427                                       .findByP_N(parentCategoryId, name, start, end,
1428                            orderByComparator);
1429            }
1430    
1431            /**
1432            * Returns the first asset category in the ordered set where parentCategoryId = &#63; and name = &#63;.
1433            *
1434            * @param parentCategoryId the parent category ID
1435            * @param name the name
1436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1437            * @return the first matching asset category
1438            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1439            * @throws SystemException if a system exception occurred
1440            */
1441            public static com.liferay.portlet.asset.model.AssetCategory findByP_N_First(
1442                    long parentCategoryId, java.lang.String name,
1443                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1444                    throws com.liferay.portal.kernel.exception.SystemException,
1445                            com.liferay.portlet.asset.NoSuchCategoryException {
1446                    return getPersistence()
1447                                       .findByP_N_First(parentCategoryId, name, orderByComparator);
1448            }
1449    
1450            /**
1451            * Returns the first asset category in the ordered set where parentCategoryId = &#63; and name = &#63;.
1452            *
1453            * @param parentCategoryId the parent category ID
1454            * @param name the name
1455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1456            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
1457            * @throws SystemException if a system exception occurred
1458            */
1459            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_First(
1460                    long parentCategoryId, java.lang.String name,
1461                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1462                    throws com.liferay.portal.kernel.exception.SystemException {
1463                    return getPersistence()
1464                                       .fetchByP_N_First(parentCategoryId, name, orderByComparator);
1465            }
1466    
1467            /**
1468            * Returns the last asset category in the ordered set where parentCategoryId = &#63; and name = &#63;.
1469            *
1470            * @param parentCategoryId the parent category ID
1471            * @param name the name
1472            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1473            * @return the last matching asset category
1474            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1475            * @throws SystemException if a system exception occurred
1476            */
1477            public static com.liferay.portlet.asset.model.AssetCategory findByP_N_Last(
1478                    long parentCategoryId, java.lang.String name,
1479                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1480                    throws com.liferay.portal.kernel.exception.SystemException,
1481                            com.liferay.portlet.asset.NoSuchCategoryException {
1482                    return getPersistence()
1483                                       .findByP_N_Last(parentCategoryId, name, orderByComparator);
1484            }
1485    
1486            /**
1487            * Returns the last asset category in the ordered set where parentCategoryId = &#63; and name = &#63;.
1488            *
1489            * @param parentCategoryId the parent category ID
1490            * @param name the name
1491            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1492            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
1493            * @throws SystemException if a system exception occurred
1494            */
1495            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_Last(
1496                    long parentCategoryId, java.lang.String name,
1497                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1498                    throws com.liferay.portal.kernel.exception.SystemException {
1499                    return getPersistence()
1500                                       .fetchByP_N_Last(parentCategoryId, name, orderByComparator);
1501            }
1502    
1503            /**
1504            * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = &#63; and name = &#63;.
1505            *
1506            * @param categoryId the primary key of the current asset category
1507            * @param parentCategoryId the parent category ID
1508            * @param name the name
1509            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1510            * @return the previous, current, and next asset category
1511            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
1512            * @throws SystemException if a system exception occurred
1513            */
1514            public static com.liferay.portlet.asset.model.AssetCategory[] findByP_N_PrevAndNext(
1515                    long categoryId, long parentCategoryId, java.lang.String name,
1516                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1517                    throws com.liferay.portal.kernel.exception.SystemException,
1518                            com.liferay.portlet.asset.NoSuchCategoryException {
1519                    return getPersistence()
1520                                       .findByP_N_PrevAndNext(categoryId, parentCategoryId, name,
1521                            orderByComparator);
1522            }
1523    
1524            /**
1525            * Removes all the asset categories where parentCategoryId = &#63; and name = &#63; from the database.
1526            *
1527            * @param parentCategoryId the parent category ID
1528            * @param name the name
1529            * @throws SystemException if a system exception occurred
1530            */
1531            public static void removeByP_N(long parentCategoryId, java.lang.String name)
1532                    throws com.liferay.portal.kernel.exception.SystemException {
1533                    getPersistence().removeByP_N(parentCategoryId, name);
1534            }
1535    
1536            /**
1537            * Returns the number of asset categories where parentCategoryId = &#63; and name = &#63;.
1538            *
1539            * @param parentCategoryId the parent category ID
1540            * @param name the name
1541            * @return the number of matching asset categories
1542            * @throws SystemException if a system exception occurred
1543            */
1544            public static int countByP_N(long parentCategoryId, java.lang.String name)
1545                    throws com.liferay.portal.kernel.exception.SystemException {
1546                    return getPersistence().countByP_N(parentCategoryId, name);
1547            }
1548    
1549            /**
1550            * Returns all the asset categories where parentCategoryId = &#63; and vocabularyId = &#63;.
1551            *
1552            * @param parentCategoryId the parent category ID
1553            * @param vocabularyId the vocabulary ID
1554            * @return the matching asset categories
1555            * @throws SystemException if a system exception occurred
1556            */
1557            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_V(
1558                    long parentCategoryId, long vocabularyId)
1559                    throws com.liferay.portal.kernel.exception.SystemException {
1560                    return getPersistence().findByP_V(parentCategoryId, vocabularyId);
1561            }
1562    
1563            /**
1564            * Returns a range of all the asset categories where parentCategoryId = &#63; and vocabularyId = &#63;.
1565            *
1566            * <p>
1567            * 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.
1568            * </p>
1569            *
1570            * @param parentCategoryId the parent category ID
1571            * @param vocabularyId the vocabulary ID
1572            * @param start the lower bound of the range of asset categories
1573            * @param end the upper bound of the range of asset categories (not inclusive)
1574            * @return the range of matching asset categories
1575            * @throws SystemException if a system exception occurred
1576            */
1577            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_V(
1578                    long parentCategoryId, long vocabularyId, int start, int end)
1579                    throws com.liferay.portal.kernel.exception.SystemException {
1580                    return getPersistence()
1581                                       .findByP_V(parentCategoryId, vocabularyId, start, end);
1582            }
1583    
1584            /**
1585            * Returns an ordered range of all the asset categories where parentCategoryId = &#63; and vocabularyId = &#63;.
1586            *
1587            * <p>
1588            * 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.
1589            * </p>
1590            *
1591            * @param parentCategoryId the parent category ID
1592            * @param vocabularyId the vocabulary ID
1593            * @param start the lower bound of the range of asset categories
1594            * @param end the upper bound of the range of asset categories (not inclusive)
1595            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1596            * @return the ordered range of matching asset categories
1597            * @throws SystemException if a system exception occurred
1598            */
1599            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_V(
1600                    long parentCategoryId, long vocabularyId, int start, int end,
1601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1602                    throws com.liferay.portal.kernel.exception.SystemException {
1603                    return getPersistence()
1604                                       .findByP_V(parentCategoryId, vocabularyId, start, end,
1605                            orderByComparator);
1606            }
1607    
1608            /**
1609            * Returns the first asset category in the ordered set where parentCategoryId = &#63; and vocabularyId = &#63;.
1610            *
1611            * @param parentCategoryId the parent category ID
1612            * @param vocabularyId the vocabulary ID
1613            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1614            * @return the first matching asset category
1615            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1616            * @throws SystemException if a system exception occurred
1617            */
1618            public static com.liferay.portlet.asset.model.AssetCategory findByP_V_First(
1619                    long parentCategoryId, long vocabularyId,
1620                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1621                    throws com.liferay.portal.kernel.exception.SystemException,
1622                            com.liferay.portlet.asset.NoSuchCategoryException {
1623                    return getPersistence()
1624                                       .findByP_V_First(parentCategoryId, vocabularyId,
1625                            orderByComparator);
1626            }
1627    
1628            /**
1629            * Returns the first asset category in the ordered set where parentCategoryId = &#63; and vocabularyId = &#63;.
1630            *
1631            * @param parentCategoryId the parent category ID
1632            * @param vocabularyId the vocabulary ID
1633            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1634            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
1635            * @throws SystemException if a system exception occurred
1636            */
1637            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_V_First(
1638                    long parentCategoryId, long vocabularyId,
1639                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1640                    throws com.liferay.portal.kernel.exception.SystemException {
1641                    return getPersistence()
1642                                       .fetchByP_V_First(parentCategoryId, vocabularyId,
1643                            orderByComparator);
1644            }
1645    
1646            /**
1647            * Returns the last asset category in the ordered set where parentCategoryId = &#63; and vocabularyId = &#63;.
1648            *
1649            * @param parentCategoryId the parent category ID
1650            * @param vocabularyId the vocabulary ID
1651            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1652            * @return the last matching asset category
1653            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1654            * @throws SystemException if a system exception occurred
1655            */
1656            public static com.liferay.portlet.asset.model.AssetCategory findByP_V_Last(
1657                    long parentCategoryId, long vocabularyId,
1658                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1659                    throws com.liferay.portal.kernel.exception.SystemException,
1660                            com.liferay.portlet.asset.NoSuchCategoryException {
1661                    return getPersistence()
1662                                       .findByP_V_Last(parentCategoryId, vocabularyId,
1663                            orderByComparator);
1664            }
1665    
1666            /**
1667            * Returns the last asset category in the ordered set where parentCategoryId = &#63; and vocabularyId = &#63;.
1668            *
1669            * @param parentCategoryId the parent category ID
1670            * @param vocabularyId the vocabulary ID
1671            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1672            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
1673            * @throws SystemException if a system exception occurred
1674            */
1675            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_V_Last(
1676                    long parentCategoryId, long vocabularyId,
1677                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1678                    throws com.liferay.portal.kernel.exception.SystemException {
1679                    return getPersistence()
1680                                       .fetchByP_V_Last(parentCategoryId, vocabularyId,
1681                            orderByComparator);
1682            }
1683    
1684            /**
1685            * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = &#63; and vocabularyId = &#63;.
1686            *
1687            * @param categoryId the primary key of the current asset category
1688            * @param parentCategoryId the parent category ID
1689            * @param vocabularyId the vocabulary ID
1690            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1691            * @return the previous, current, and next asset category
1692            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
1693            * @throws SystemException if a system exception occurred
1694            */
1695            public static com.liferay.portlet.asset.model.AssetCategory[] findByP_V_PrevAndNext(
1696                    long categoryId, long parentCategoryId, long vocabularyId,
1697                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1698                    throws com.liferay.portal.kernel.exception.SystemException,
1699                            com.liferay.portlet.asset.NoSuchCategoryException {
1700                    return getPersistence()
1701                                       .findByP_V_PrevAndNext(categoryId, parentCategoryId,
1702                            vocabularyId, orderByComparator);
1703            }
1704    
1705            /**
1706            * Removes all the asset categories where parentCategoryId = &#63; and vocabularyId = &#63; from the database.
1707            *
1708            * @param parentCategoryId the parent category ID
1709            * @param vocabularyId the vocabulary ID
1710            * @throws SystemException if a system exception occurred
1711            */
1712            public static void removeByP_V(long parentCategoryId, long vocabularyId)
1713                    throws com.liferay.portal.kernel.exception.SystemException {
1714                    getPersistence().removeByP_V(parentCategoryId, vocabularyId);
1715            }
1716    
1717            /**
1718            * Returns the number of asset categories where parentCategoryId = &#63; and vocabularyId = &#63;.
1719            *
1720            * @param parentCategoryId the parent category ID
1721            * @param vocabularyId the vocabulary ID
1722            * @return the number of matching asset categories
1723            * @throws SystemException if a system exception occurred
1724            */
1725            public static int countByP_V(long parentCategoryId, long vocabularyId)
1726                    throws com.liferay.portal.kernel.exception.SystemException {
1727                    return getPersistence().countByP_V(parentCategoryId, vocabularyId);
1728            }
1729    
1730            /**
1731            * Returns all the asset categories where name = &#63; and vocabularyId = &#63;.
1732            *
1733            * @param name the name
1734            * @param vocabularyId the vocabulary ID
1735            * @return the matching asset categories
1736            * @throws SystemException if a system exception occurred
1737            */
1738            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByN_V(
1739                    java.lang.String name, long vocabularyId)
1740                    throws com.liferay.portal.kernel.exception.SystemException {
1741                    return getPersistence().findByN_V(name, vocabularyId);
1742            }
1743    
1744            /**
1745            * Returns a range of all the asset categories where name = &#63; and vocabularyId = &#63;.
1746            *
1747            * <p>
1748            * 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.
1749            * </p>
1750            *
1751            * @param name the name
1752            * @param vocabularyId the vocabulary ID
1753            * @param start the lower bound of the range of asset categories
1754            * @param end the upper bound of the range of asset categories (not inclusive)
1755            * @return the range of matching asset categories
1756            * @throws SystemException if a system exception occurred
1757            */
1758            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByN_V(
1759                    java.lang.String name, long vocabularyId, int start, int end)
1760                    throws com.liferay.portal.kernel.exception.SystemException {
1761                    return getPersistence().findByN_V(name, vocabularyId, start, end);
1762            }
1763    
1764            /**
1765            * Returns an ordered range of all the asset categories where name = &#63; and vocabularyId = &#63;.
1766            *
1767            * <p>
1768            * 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.
1769            * </p>
1770            *
1771            * @param name the name
1772            * @param vocabularyId the vocabulary ID
1773            * @param start the lower bound of the range of asset categories
1774            * @param end the upper bound of the range of asset categories (not inclusive)
1775            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1776            * @return the ordered range of matching asset categories
1777            * @throws SystemException if a system exception occurred
1778            */
1779            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByN_V(
1780                    java.lang.String name, long vocabularyId, int start, int end,
1781                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1782                    throws com.liferay.portal.kernel.exception.SystemException {
1783                    return getPersistence()
1784                                       .findByN_V(name, vocabularyId, start, end, orderByComparator);
1785            }
1786    
1787            /**
1788            * Returns the first asset category in the ordered set where name = &#63; and vocabularyId = &#63;.
1789            *
1790            * @param name the name
1791            * @param vocabularyId the vocabulary ID
1792            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1793            * @return the first matching asset category
1794            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1795            * @throws SystemException if a system exception occurred
1796            */
1797            public static com.liferay.portlet.asset.model.AssetCategory findByN_V_First(
1798                    java.lang.String name, long vocabularyId,
1799                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1800                    throws com.liferay.portal.kernel.exception.SystemException,
1801                            com.liferay.portlet.asset.NoSuchCategoryException {
1802                    return getPersistence()
1803                                       .findByN_V_First(name, vocabularyId, orderByComparator);
1804            }
1805    
1806            /**
1807            * Returns the first asset category in the ordered set where name = &#63; and vocabularyId = &#63;.
1808            *
1809            * @param name the name
1810            * @param vocabularyId the vocabulary ID
1811            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1812            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
1813            * @throws SystemException if a system exception occurred
1814            */
1815            public static com.liferay.portlet.asset.model.AssetCategory fetchByN_V_First(
1816                    java.lang.String name, long vocabularyId,
1817                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1818                    throws com.liferay.portal.kernel.exception.SystemException {
1819                    return getPersistence()
1820                                       .fetchByN_V_First(name, vocabularyId, orderByComparator);
1821            }
1822    
1823            /**
1824            * Returns the last asset category in the ordered set where name = &#63; and vocabularyId = &#63;.
1825            *
1826            * @param name the name
1827            * @param vocabularyId the vocabulary ID
1828            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1829            * @return the last matching asset category
1830            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1831            * @throws SystemException if a system exception occurred
1832            */
1833            public static com.liferay.portlet.asset.model.AssetCategory findByN_V_Last(
1834                    java.lang.String name, long vocabularyId,
1835                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1836                    throws com.liferay.portal.kernel.exception.SystemException,
1837                            com.liferay.portlet.asset.NoSuchCategoryException {
1838                    return getPersistence()
1839                                       .findByN_V_Last(name, vocabularyId, orderByComparator);
1840            }
1841    
1842            /**
1843            * Returns the last asset category in the ordered set where name = &#63; and vocabularyId = &#63;.
1844            *
1845            * @param name the name
1846            * @param vocabularyId the vocabulary ID
1847            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1848            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
1849            * @throws SystemException if a system exception occurred
1850            */
1851            public static com.liferay.portlet.asset.model.AssetCategory fetchByN_V_Last(
1852                    java.lang.String name, long vocabularyId,
1853                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1854                    throws com.liferay.portal.kernel.exception.SystemException {
1855                    return getPersistence()
1856                                       .fetchByN_V_Last(name, vocabularyId, orderByComparator);
1857            }
1858    
1859            /**
1860            * Returns the asset categories before and after the current asset category in the ordered set where name = &#63; and vocabularyId = &#63;.
1861            *
1862            * @param categoryId the primary key of the current asset category
1863            * @param name the name
1864            * @param vocabularyId the vocabulary ID
1865            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1866            * @return the previous, current, and next asset category
1867            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
1868            * @throws SystemException if a system exception occurred
1869            */
1870            public static com.liferay.portlet.asset.model.AssetCategory[] findByN_V_PrevAndNext(
1871                    long categoryId, java.lang.String name, long vocabularyId,
1872                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1873                    throws com.liferay.portal.kernel.exception.SystemException,
1874                            com.liferay.portlet.asset.NoSuchCategoryException {
1875                    return getPersistence()
1876                                       .findByN_V_PrevAndNext(categoryId, name, vocabularyId,
1877                            orderByComparator);
1878            }
1879    
1880            /**
1881            * Removes all the asset categories where name = &#63; and vocabularyId = &#63; from the database.
1882            *
1883            * @param name the name
1884            * @param vocabularyId the vocabulary ID
1885            * @throws SystemException if a system exception occurred
1886            */
1887            public static void removeByN_V(java.lang.String name, long vocabularyId)
1888                    throws com.liferay.portal.kernel.exception.SystemException {
1889                    getPersistence().removeByN_V(name, vocabularyId);
1890            }
1891    
1892            /**
1893            * Returns the number of asset categories where name = &#63; and vocabularyId = &#63;.
1894            *
1895            * @param name the name
1896            * @param vocabularyId the vocabulary ID
1897            * @return the number of matching asset categories
1898            * @throws SystemException if a system exception occurred
1899            */
1900            public static int countByN_V(java.lang.String name, long vocabularyId)
1901                    throws com.liferay.portal.kernel.exception.SystemException {
1902                    return getPersistence().countByN_V(name, vocabularyId);
1903            }
1904    
1905            /**
1906            * 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.
1907            *
1908            * @param parentCategoryId the parent category ID
1909            * @param name the name
1910            * @param vocabularyId the vocabulary ID
1911            * @return the matching asset category
1912            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
1913            * @throws SystemException if a system exception occurred
1914            */
1915            public static com.liferay.portlet.asset.model.AssetCategory findByP_N_V(
1916                    long parentCategoryId, java.lang.String name, long vocabularyId)
1917                    throws com.liferay.portal.kernel.exception.SystemException,
1918                            com.liferay.portlet.asset.NoSuchCategoryException {
1919                    return getPersistence().findByP_N_V(parentCategoryId, name, vocabularyId);
1920            }
1921    
1922            /**
1923            * 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.
1924            *
1925            * @param parentCategoryId the parent category ID
1926            * @param name the name
1927            * @param vocabularyId the vocabulary ID
1928            * @return the matching asset category, or <code>null</code> if a matching asset category could not be found
1929            * @throws SystemException if a system exception occurred
1930            */
1931            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_V(
1932                    long parentCategoryId, java.lang.String name, long vocabularyId)
1933                    throws com.liferay.portal.kernel.exception.SystemException {
1934                    return getPersistence()
1935                                       .fetchByP_N_V(parentCategoryId, name, vocabularyId);
1936            }
1937    
1938            /**
1939            * 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.
1940            *
1941            * @param parentCategoryId the parent category ID
1942            * @param name the name
1943            * @param vocabularyId the vocabulary ID
1944            * @param retrieveFromCache whether to use the finder cache
1945            * @return the matching asset category, or <code>null</code> if a matching asset category could not be found
1946            * @throws SystemException if a system exception occurred
1947            */
1948            public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_V(
1949                    long parentCategoryId, java.lang.String name, long vocabularyId,
1950                    boolean retrieveFromCache)
1951                    throws com.liferay.portal.kernel.exception.SystemException {
1952                    return getPersistence()
1953                                       .fetchByP_N_V(parentCategoryId, name, vocabularyId,
1954                            retrieveFromCache);
1955            }
1956    
1957            /**
1958            * Removes the asset category where parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63; from the database.
1959            *
1960            * @param parentCategoryId the parent category ID
1961            * @param name the name
1962            * @param vocabularyId the vocabulary ID
1963            * @return the asset category that was removed
1964            * @throws SystemException if a system exception occurred
1965            */
1966            public static com.liferay.portlet.asset.model.AssetCategory removeByP_N_V(
1967                    long parentCategoryId, java.lang.String name, long vocabularyId)
1968                    throws com.liferay.portal.kernel.exception.SystemException,
1969                            com.liferay.portlet.asset.NoSuchCategoryException {
1970                    return getPersistence()
1971                                       .removeByP_N_V(parentCategoryId, name, vocabularyId);
1972            }
1973    
1974            /**
1975            * Returns the number of asset categories where parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
1976            *
1977            * @param parentCategoryId the parent category ID
1978            * @param name the name
1979            * @param vocabularyId the vocabulary ID
1980            * @return the number of matching asset categories
1981            * @throws SystemException if a system exception occurred
1982            */
1983            public static int countByP_N_V(long parentCategoryId,
1984                    java.lang.String name, long vocabularyId)
1985                    throws com.liferay.portal.kernel.exception.SystemException {
1986                    return getPersistence()
1987                                       .countByP_N_V(parentCategoryId, name, vocabularyId);
1988            }
1989    
1990            /**
1991            * Returns all the asset categories where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
1992            *
1993            * @param groupId the group ID
1994            * @param parentCategoryId the parent category ID
1995            * @param name the name
1996            * @param vocabularyId the vocabulary ID
1997            * @return the matching asset categories
1998            * @throws SystemException if a system exception occurred
1999            */
2000            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_N_V(
2001                    long groupId, long parentCategoryId, java.lang.String name,
2002                    long vocabularyId)
2003                    throws com.liferay.portal.kernel.exception.SystemException {
2004                    return getPersistence()
2005                                       .findByG_P_N_V(groupId, parentCategoryId, name, vocabularyId);
2006            }
2007    
2008            /**
2009            * Returns a range of all the asset categories where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2010            *
2011            * <p>
2012            * 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.
2013            * </p>
2014            *
2015            * @param groupId the group ID
2016            * @param parentCategoryId the parent category ID
2017            * @param name the name
2018            * @param vocabularyId the vocabulary ID
2019            * @param start the lower bound of the range of asset categories
2020            * @param end the upper bound of the range of asset categories (not inclusive)
2021            * @return the range of matching asset categories
2022            * @throws SystemException if a system exception occurred
2023            */
2024            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_N_V(
2025                    long groupId, long parentCategoryId, java.lang.String name,
2026                    long vocabularyId, int start, int end)
2027                    throws com.liferay.portal.kernel.exception.SystemException {
2028                    return getPersistence()
2029                                       .findByG_P_N_V(groupId, parentCategoryId, name,
2030                            vocabularyId, start, end);
2031            }
2032    
2033            /**
2034            * Returns an ordered range of all the asset categories where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2035            *
2036            * <p>
2037            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.
2038            * </p>
2039            *
2040            * @param groupId the group ID
2041            * @param parentCategoryId the parent category ID
2042            * @param name the name
2043            * @param vocabularyId the vocabulary ID
2044            * @param start the lower bound of the range of asset categories
2045            * @param end the upper bound of the range of asset categories (not inclusive)
2046            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2047            * @return the ordered range of matching asset categories
2048            * @throws SystemException if a system exception occurred
2049            */
2050            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_N_V(
2051                    long groupId, long parentCategoryId, java.lang.String name,
2052                    long vocabularyId, int start, int end,
2053                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2054                    throws com.liferay.portal.kernel.exception.SystemException {
2055                    return getPersistence()
2056                                       .findByG_P_N_V(groupId, parentCategoryId, name,
2057                            vocabularyId, start, end, orderByComparator);
2058            }
2059    
2060            /**
2061            * Returns the first asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2062            *
2063            * @param groupId the group ID
2064            * @param parentCategoryId the parent category ID
2065            * @param name the name
2066            * @param vocabularyId the vocabulary ID
2067            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2068            * @return the first matching asset category
2069            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
2070            * @throws SystemException if a system exception occurred
2071            */
2072            public static com.liferay.portlet.asset.model.AssetCategory findByG_P_N_V_First(
2073                    long groupId, long parentCategoryId, java.lang.String name,
2074                    long vocabularyId,
2075                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2076                    throws com.liferay.portal.kernel.exception.SystemException,
2077                            com.liferay.portlet.asset.NoSuchCategoryException {
2078                    return getPersistence()
2079                                       .findByG_P_N_V_First(groupId, parentCategoryId, name,
2080                            vocabularyId, orderByComparator);
2081            }
2082    
2083            /**
2084            * Returns the first asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2085            *
2086            * @param groupId the group ID
2087            * @param parentCategoryId the parent category ID
2088            * @param name the name
2089            * @param vocabularyId the vocabulary ID
2090            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2091            * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found
2092            * @throws SystemException if a system exception occurred
2093            */
2094            public static com.liferay.portlet.asset.model.AssetCategory fetchByG_P_N_V_First(
2095                    long groupId, long parentCategoryId, java.lang.String name,
2096                    long vocabularyId,
2097                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2098                    throws com.liferay.portal.kernel.exception.SystemException {
2099                    return getPersistence()
2100                                       .fetchByG_P_N_V_First(groupId, parentCategoryId, name,
2101                            vocabularyId, orderByComparator);
2102            }
2103    
2104            /**
2105            * Returns the last asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2106            *
2107            * @param groupId the group ID
2108            * @param parentCategoryId the parent category ID
2109            * @param name the name
2110            * @param vocabularyId the vocabulary ID
2111            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2112            * @return the last matching asset category
2113            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found
2114            * @throws SystemException if a system exception occurred
2115            */
2116            public static com.liferay.portlet.asset.model.AssetCategory findByG_P_N_V_Last(
2117                    long groupId, long parentCategoryId, java.lang.String name,
2118                    long vocabularyId,
2119                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2120                    throws com.liferay.portal.kernel.exception.SystemException,
2121                            com.liferay.portlet.asset.NoSuchCategoryException {
2122                    return getPersistence()
2123                                       .findByG_P_N_V_Last(groupId, parentCategoryId, name,
2124                            vocabularyId, orderByComparator);
2125            }
2126    
2127            /**
2128            * Returns the last asset category in the ordered set where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2129            *
2130            * @param groupId the group ID
2131            * @param parentCategoryId the parent category ID
2132            * @param name the name
2133            * @param vocabularyId the vocabulary ID
2134            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2135            * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found
2136            * @throws SystemException if a system exception occurred
2137            */
2138            public static com.liferay.portlet.asset.model.AssetCategory fetchByG_P_N_V_Last(
2139                    long groupId, long parentCategoryId, java.lang.String name,
2140                    long vocabularyId,
2141                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2142                    throws com.liferay.portal.kernel.exception.SystemException {
2143                    return getPersistence()
2144                                       .fetchByG_P_N_V_Last(groupId, parentCategoryId, name,
2145                            vocabularyId, orderByComparator);
2146            }
2147    
2148            /**
2149            * 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;.
2150            *
2151            * @param categoryId the primary key of the current asset category
2152            * @param groupId the group ID
2153            * @param parentCategoryId the parent category ID
2154            * @param name the name
2155            * @param vocabularyId the vocabulary ID
2156            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2157            * @return the previous, current, and next asset category
2158            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
2159            * @throws SystemException if a system exception occurred
2160            */
2161            public static com.liferay.portlet.asset.model.AssetCategory[] findByG_P_N_V_PrevAndNext(
2162                    long categoryId, long groupId, long parentCategoryId,
2163                    java.lang.String name, long vocabularyId,
2164                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2165                    throws com.liferay.portal.kernel.exception.SystemException,
2166                            com.liferay.portlet.asset.NoSuchCategoryException {
2167                    return getPersistence()
2168                                       .findByG_P_N_V_PrevAndNext(categoryId, groupId,
2169                            parentCategoryId, name, vocabularyId, orderByComparator);
2170            }
2171    
2172            /**
2173            * Returns all the asset categories that the user has permission to view where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2174            *
2175            * @param groupId the group ID
2176            * @param parentCategoryId the parent category ID
2177            * @param name the name
2178            * @param vocabularyId the vocabulary ID
2179            * @return the matching asset categories that the user has permission to view
2180            * @throws SystemException if a system exception occurred
2181            */
2182            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_N_V(
2183                    long groupId, long parentCategoryId, java.lang.String name,
2184                    long vocabularyId)
2185                    throws com.liferay.portal.kernel.exception.SystemException {
2186                    return getPersistence()
2187                                       .filterFindByG_P_N_V(groupId, parentCategoryId, name,
2188                            vocabularyId);
2189            }
2190    
2191            /**
2192            * 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;.
2193            *
2194            * <p>
2195            * 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.
2196            * </p>
2197            *
2198            * @param groupId the group ID
2199            * @param parentCategoryId the parent category ID
2200            * @param name the name
2201            * @param vocabularyId the vocabulary ID
2202            * @param start the lower bound of the range of asset categories
2203            * @param end the upper bound of the range of asset categories (not inclusive)
2204            * @return the range of matching asset categories that the user has permission to view
2205            * @throws SystemException if a system exception occurred
2206            */
2207            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_N_V(
2208                    long groupId, long parentCategoryId, java.lang.String name,
2209                    long vocabularyId, int start, int end)
2210                    throws com.liferay.portal.kernel.exception.SystemException {
2211                    return getPersistence()
2212                                       .filterFindByG_P_N_V(groupId, parentCategoryId, name,
2213                            vocabularyId, start, end);
2214            }
2215    
2216            /**
2217            * 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;.
2218            *
2219            * <p>
2220            * 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.
2221            * </p>
2222            *
2223            * @param groupId the group ID
2224            * @param parentCategoryId the parent category ID
2225            * @param name the name
2226            * @param vocabularyId the vocabulary ID
2227            * @param start the lower bound of the range of asset categories
2228            * @param end the upper bound of the range of asset categories (not inclusive)
2229            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2230            * @return the ordered range of matching asset categories that the user has permission to view
2231            * @throws SystemException if a system exception occurred
2232            */
2233            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_N_V(
2234                    long groupId, long parentCategoryId, java.lang.String name,
2235                    long vocabularyId, int start, int end,
2236                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2237                    throws com.liferay.portal.kernel.exception.SystemException {
2238                    return getPersistence()
2239                                       .filterFindByG_P_N_V(groupId, parentCategoryId, name,
2240                            vocabularyId, start, end, orderByComparator);
2241            }
2242    
2243            /**
2244            * 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;.
2245            *
2246            * @param categoryId the primary key of the current asset category
2247            * @param groupId the group ID
2248            * @param parentCategoryId the parent category ID
2249            * @param name the name
2250            * @param vocabularyId the vocabulary ID
2251            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2252            * @return the previous, current, and next asset category
2253            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
2254            * @throws SystemException if a system exception occurred
2255            */
2256            public static com.liferay.portlet.asset.model.AssetCategory[] filterFindByG_P_N_V_PrevAndNext(
2257                    long categoryId, long groupId, long parentCategoryId,
2258                    java.lang.String name, long vocabularyId,
2259                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2260                    throws com.liferay.portal.kernel.exception.SystemException,
2261                            com.liferay.portlet.asset.NoSuchCategoryException {
2262                    return getPersistence()
2263                                       .filterFindByG_P_N_V_PrevAndNext(categoryId, groupId,
2264                            parentCategoryId, name, vocabularyId, orderByComparator);
2265            }
2266    
2267            /**
2268            * Removes all the asset categories where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63; from the database.
2269            *
2270            * @param groupId the group ID
2271            * @param parentCategoryId the parent category ID
2272            * @param name the name
2273            * @param vocabularyId the vocabulary ID
2274            * @throws SystemException if a system exception occurred
2275            */
2276            public static void removeByG_P_N_V(long groupId, long parentCategoryId,
2277                    java.lang.String name, long vocabularyId)
2278                    throws com.liferay.portal.kernel.exception.SystemException {
2279                    getPersistence()
2280                            .removeByG_P_N_V(groupId, parentCategoryId, name, vocabularyId);
2281            }
2282    
2283            /**
2284            * Returns the number of asset categories where groupId = &#63; and parentCategoryId = &#63; and name = &#63; and vocabularyId = &#63;.
2285            *
2286            * @param groupId the group ID
2287            * @param parentCategoryId the parent category ID
2288            * @param name the name
2289            * @param vocabularyId the vocabulary ID
2290            * @return the number of matching asset categories
2291            * @throws SystemException if a system exception occurred
2292            */
2293            public static int countByG_P_N_V(long groupId, long parentCategoryId,
2294                    java.lang.String name, long vocabularyId)
2295                    throws com.liferay.portal.kernel.exception.SystemException {
2296                    return getPersistence()
2297                                       .countByG_P_N_V(groupId, parentCategoryId, name, vocabularyId);
2298            }
2299    
2300            /**
2301            * 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;.
2302            *
2303            * @param groupId the group ID
2304            * @param parentCategoryId the parent category ID
2305            * @param name the name
2306            * @param vocabularyId the vocabulary ID
2307            * @return the number of matching asset categories that the user has permission to view
2308            * @throws SystemException if a system exception occurred
2309            */
2310            public static int filterCountByG_P_N_V(long groupId, long parentCategoryId,
2311                    java.lang.String name, long vocabularyId)
2312                    throws com.liferay.portal.kernel.exception.SystemException {
2313                    return getPersistence()
2314                                       .filterCountByG_P_N_V(groupId, parentCategoryId, name,
2315                            vocabularyId);
2316            }
2317    
2318            /**
2319            * Caches the asset category in the entity cache if it is enabled.
2320            *
2321            * @param assetCategory the asset category
2322            */
2323            public static void cacheResult(
2324                    com.liferay.portlet.asset.model.AssetCategory assetCategory) {
2325                    getPersistence().cacheResult(assetCategory);
2326            }
2327    
2328            /**
2329            * Caches the asset categories in the entity cache if it is enabled.
2330            *
2331            * @param assetCategories the asset categories
2332            */
2333            public static void cacheResult(
2334                    java.util.List<com.liferay.portlet.asset.model.AssetCategory> assetCategories) {
2335                    getPersistence().cacheResult(assetCategories);
2336            }
2337    
2338            /**
2339            * Creates a new asset category with the primary key. Does not add the asset category to the database.
2340            *
2341            * @param categoryId the primary key for the new asset category
2342            * @return the new asset category
2343            */
2344            public static com.liferay.portlet.asset.model.AssetCategory create(
2345                    long categoryId) {
2346                    return getPersistence().create(categoryId);
2347            }
2348    
2349            /**
2350            * Removes the asset category with the primary key from the database. Also notifies the appropriate model listeners.
2351            *
2352            * @param categoryId the primary key of the asset category
2353            * @return the asset category that was removed
2354            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
2355            * @throws SystemException if a system exception occurred
2356            */
2357            public static com.liferay.portlet.asset.model.AssetCategory remove(
2358                    long categoryId)
2359                    throws com.liferay.portal.kernel.exception.SystemException,
2360                            com.liferay.portlet.asset.NoSuchCategoryException {
2361                    return getPersistence().remove(categoryId);
2362            }
2363    
2364            public static com.liferay.portlet.asset.model.AssetCategory updateImpl(
2365                    com.liferay.portlet.asset.model.AssetCategory assetCategory)
2366                    throws com.liferay.portal.kernel.exception.SystemException {
2367                    return getPersistence().updateImpl(assetCategory);
2368            }
2369    
2370            /**
2371            * Returns the asset category with the primary key or throws a {@link com.liferay.portlet.asset.NoSuchCategoryException} if it could not be found.
2372            *
2373            * @param categoryId the primary key of the asset category
2374            * @return the asset category
2375            * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found
2376            * @throws SystemException if a system exception occurred
2377            */
2378            public static com.liferay.portlet.asset.model.AssetCategory findByPrimaryKey(
2379                    long categoryId)
2380                    throws com.liferay.portal.kernel.exception.SystemException,
2381                            com.liferay.portlet.asset.NoSuchCategoryException {
2382                    return getPersistence().findByPrimaryKey(categoryId);
2383            }
2384    
2385            /**
2386            * Returns the asset category with the primary key or returns <code>null</code> if it could not be found.
2387            *
2388            * @param categoryId the primary key of the asset category
2389            * @return the asset category, or <code>null</code> if a asset category with the primary key could not be found
2390            * @throws SystemException if a system exception occurred
2391            */
2392            public static com.liferay.portlet.asset.model.AssetCategory fetchByPrimaryKey(
2393                    long categoryId)
2394                    throws com.liferay.portal.kernel.exception.SystemException {
2395                    return getPersistence().fetchByPrimaryKey(categoryId);
2396            }
2397    
2398            /**
2399            * Returns all the asset categories.
2400            *
2401            * @return the asset categories
2402            * @throws SystemException if a system exception occurred
2403            */
2404            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findAll()
2405                    throws com.liferay.portal.kernel.exception.SystemException {
2406                    return getPersistence().findAll();
2407            }
2408    
2409            /**
2410            * Returns a range of all the asset categories.
2411            *
2412            * <p>
2413            * 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.
2414            * </p>
2415            *
2416            * @param start the lower bound of the range of asset categories
2417            * @param end the upper bound of the range of asset categories (not inclusive)
2418            * @return the range of asset categories
2419            * @throws SystemException if a system exception occurred
2420            */
2421            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findAll(
2422                    int start, int end)
2423                    throws com.liferay.portal.kernel.exception.SystemException {
2424                    return getPersistence().findAll(start, end);
2425            }
2426    
2427            /**
2428            * Returns an ordered range of all the asset categories.
2429            *
2430            * <p>
2431            * 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.
2432            * </p>
2433            *
2434            * @param start the lower bound of the range of asset categories
2435            * @param end the upper bound of the range of asset categories (not inclusive)
2436            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2437            * @return the ordered range of asset categories
2438            * @throws SystemException if a system exception occurred
2439            */
2440            public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findAll(
2441                    int start, int end,
2442                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2443                    throws com.liferay.portal.kernel.exception.SystemException {
2444                    return getPersistence().findAll(start, end, orderByComparator);
2445            }
2446    
2447            /**
2448            * Removes all the asset categories from the database.
2449            *
2450            * @throws SystemException if a system exception occurred
2451            */
2452            public static void removeAll()
2453                    throws com.liferay.portal.kernel.exception.SystemException {
2454                    getPersistence().removeAll();
2455            }
2456    
2457            /**
2458            * Returns the number of asset categories.
2459            *
2460            * @return the number of asset categories
2461            * @throws SystemException if a system exception occurred
2462            */
2463            public static int countAll()
2464                    throws com.liferay.portal.kernel.exception.SystemException {
2465                    return getPersistence().countAll();
2466            }
2467    
2468            /**
2469            * Returns all the asset entries associated with the asset category.
2470            *
2471            * @param pk the primary key of the asset category
2472            * @return the asset entries associated with the asset category
2473            * @throws SystemException if a system exception occurred
2474            */
2475            public static java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
2476                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
2477                    return getPersistence().getAssetEntries(pk);
2478            }
2479    
2480            /**
2481            * Returns a range of all the asset entries associated with the asset category.
2482            *
2483            * <p>
2484            * 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.
2485            * </p>
2486            *
2487            * @param pk the primary key of the asset category
2488            * @param start the lower bound of the range of asset categories
2489            * @param end the upper bound of the range of asset categories (not inclusive)
2490            * @return the range of asset entries associated with the asset category
2491            * @throws SystemException if a system exception occurred
2492            */
2493            public static java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
2494                    long pk, int start, int end)
2495                    throws com.liferay.portal.kernel.exception.SystemException {
2496                    return getPersistence().getAssetEntries(pk, start, end);
2497            }
2498    
2499            /**
2500            * Returns an ordered range of all the asset entries associated with the asset category.
2501            *
2502            * <p>
2503            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.
2504            * </p>
2505            *
2506            * @param pk the primary key of the asset category
2507            * @param start the lower bound of the range of asset categories
2508            * @param end the upper bound of the range of asset categories (not inclusive)
2509            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2510            * @return the ordered range of asset entries associated with the asset category
2511            * @throws SystemException if a system exception occurred
2512            */
2513            public static java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
2514                    long pk, int start, int end,
2515                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2516                    throws com.liferay.portal.kernel.exception.SystemException {
2517                    return getPersistence()
2518                                       .getAssetEntries(pk, start, end, orderByComparator);
2519            }
2520    
2521            /**
2522            * Returns the number of asset entries associated with the asset category.
2523            *
2524            * @param pk the primary key of the asset category
2525            * @return the number of asset entries associated with the asset category
2526            * @throws SystemException if a system exception occurred
2527            */
2528            public static int getAssetEntriesSize(long pk)
2529                    throws com.liferay.portal.kernel.exception.SystemException {
2530                    return getPersistence().getAssetEntriesSize(pk);
2531            }
2532    
2533            /**
2534            * Returns <code>true</code> if the asset entry is associated with the asset category.
2535            *
2536            * @param pk the primary key of the asset category
2537            * @param assetEntryPK the primary key of the asset entry
2538            * @return <code>true</code> if the asset entry is associated with the asset category; <code>false</code> otherwise
2539            * @throws SystemException if a system exception occurred
2540            */
2541            public static boolean containsAssetEntry(long pk, long assetEntryPK)
2542                    throws com.liferay.portal.kernel.exception.SystemException {
2543                    return getPersistence().containsAssetEntry(pk, assetEntryPK);
2544            }
2545    
2546            /**
2547            * Returns <code>true</code> if the asset category has any asset entries associated with it.
2548            *
2549            * @param pk the primary key of the asset category to check for associations with asset entries
2550            * @return <code>true</code> if the asset category has any asset entries associated with it; <code>false</code> otherwise
2551            * @throws SystemException if a system exception occurred
2552            */
2553            public static boolean containsAssetEntries(long pk)
2554                    throws com.liferay.portal.kernel.exception.SystemException {
2555                    return getPersistence().containsAssetEntries(pk);
2556            }
2557    
2558            /**
2559            * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2560            *
2561            * @param pk the primary key of the asset category
2562            * @param assetEntryPK the primary key of the asset entry
2563            * @throws SystemException if a system exception occurred
2564            */
2565            public static void addAssetEntry(long pk, long assetEntryPK)
2566                    throws com.liferay.portal.kernel.exception.SystemException {
2567                    getPersistence().addAssetEntry(pk, assetEntryPK);
2568            }
2569    
2570            /**
2571            * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2572            *
2573            * @param pk the primary key of the asset category
2574            * @param assetEntry the asset entry
2575            * @throws SystemException if a system exception occurred
2576            */
2577            public static void addAssetEntry(long pk,
2578                    com.liferay.portlet.asset.model.AssetEntry assetEntry)
2579                    throws com.liferay.portal.kernel.exception.SystemException {
2580                    getPersistence().addAssetEntry(pk, assetEntry);
2581            }
2582    
2583            /**
2584            * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2585            *
2586            * @param pk the primary key of the asset category
2587            * @param assetEntryPKs the primary keys of the asset entries
2588            * @throws SystemException if a system exception occurred
2589            */
2590            public static void addAssetEntries(long pk, long[] assetEntryPKs)
2591                    throws com.liferay.portal.kernel.exception.SystemException {
2592                    getPersistence().addAssetEntries(pk, assetEntryPKs);
2593            }
2594    
2595            /**
2596            * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2597            *
2598            * @param pk the primary key of the asset category
2599            * @param assetEntries the asset entries
2600            * @throws SystemException if a system exception occurred
2601            */
2602            public static void addAssetEntries(long pk,
2603                    java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries)
2604                    throws com.liferay.portal.kernel.exception.SystemException {
2605                    getPersistence().addAssetEntries(pk, assetEntries);
2606            }
2607    
2608            /**
2609            * Clears all associations between the asset category and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2610            *
2611            * @param pk the primary key of the asset category to clear the associated asset entries from
2612            * @throws SystemException if a system exception occurred
2613            */
2614            public static void clearAssetEntries(long pk)
2615                    throws com.liferay.portal.kernel.exception.SystemException {
2616                    getPersistence().clearAssetEntries(pk);
2617            }
2618    
2619            /**
2620            * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2621            *
2622            * @param pk the primary key of the asset category
2623            * @param assetEntryPK the primary key of the asset entry
2624            * @throws SystemException if a system exception occurred
2625            */
2626            public static void removeAssetEntry(long pk, long assetEntryPK)
2627                    throws com.liferay.portal.kernel.exception.SystemException {
2628                    getPersistence().removeAssetEntry(pk, assetEntryPK);
2629            }
2630    
2631            /**
2632            * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2633            *
2634            * @param pk the primary key of the asset category
2635            * @param assetEntry the asset entry
2636            * @throws SystemException if a system exception occurred
2637            */
2638            public static void removeAssetEntry(long pk,
2639                    com.liferay.portlet.asset.model.AssetEntry assetEntry)
2640                    throws com.liferay.portal.kernel.exception.SystemException {
2641                    getPersistence().removeAssetEntry(pk, assetEntry);
2642            }
2643    
2644            /**
2645            * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2646            *
2647            * @param pk the primary key of the asset category
2648            * @param assetEntryPKs the primary keys of the asset entries
2649            * @throws SystemException if a system exception occurred
2650            */
2651            public static void removeAssetEntries(long pk, long[] assetEntryPKs)
2652                    throws com.liferay.portal.kernel.exception.SystemException {
2653                    getPersistence().removeAssetEntries(pk, assetEntryPKs);
2654            }
2655    
2656            /**
2657            * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2658            *
2659            * @param pk the primary key of the asset category
2660            * @param assetEntries the asset entries
2661            * @throws SystemException if a system exception occurred
2662            */
2663            public static void removeAssetEntries(long pk,
2664                    java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries)
2665                    throws com.liferay.portal.kernel.exception.SystemException {
2666                    getPersistence().removeAssetEntries(pk, assetEntries);
2667            }
2668    
2669            /**
2670            * 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.
2671            *
2672            * @param pk the primary key of the asset category
2673            * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset category
2674            * @throws SystemException if a system exception occurred
2675            */
2676            public static void setAssetEntries(long pk, long[] assetEntryPKs)
2677                    throws com.liferay.portal.kernel.exception.SystemException {
2678                    getPersistence().setAssetEntries(pk, assetEntryPKs);
2679            }
2680    
2681            /**
2682            * 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.
2683            *
2684            * @param pk the primary key of the asset category
2685            * @param assetEntries the asset entries to be associated with the asset category
2686            * @throws SystemException if a system exception occurred
2687            */
2688            public static void setAssetEntries(long pk,
2689                    java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries)
2690                    throws com.liferay.portal.kernel.exception.SystemException {
2691                    getPersistence().setAssetEntries(pk, assetEntries);
2692            }
2693    
2694            /**
2695            * Rebuilds the asset categories tree for the scope using the modified pre-order tree traversal algorithm.
2696            *
2697            * <p>
2698            * 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.
2699            * </p>
2700            *
2701            * @param groupId the ID of the scope
2702            * @param force whether to force the rebuild even if the tree is not stale
2703            */
2704            public static void rebuildTree(long groupId, boolean force)
2705                    throws com.liferay.portal.kernel.exception.SystemException {
2706                    getPersistence().rebuildTree(groupId, force);
2707            }
2708    
2709            public static void setRebuildTreeEnabled(boolean rebuildTreeEnabled) {
2710                    getPersistence().setRebuildTreeEnabled(rebuildTreeEnabled);
2711            }
2712    
2713            public static AssetCategoryPersistence getPersistence() {
2714                    if (_persistence == null) {
2715                            _persistence = (AssetCategoryPersistence)PortalBeanLocatorUtil.locate(AssetCategoryPersistence.class.getName());
2716    
2717                            ReferenceRegistry.registerReference(AssetCategoryUtil.class,
2718                                    "_persistence");
2719                    }
2720    
2721                    return _persistence;
2722            }
2723    
2724            /**
2725             * @deprecated
2726             */
2727            public void setPersistence(AssetCategoryPersistence persistence) {
2728            }
2729    
2730            private static AssetCategoryPersistence _persistence;
2731    }