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