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