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.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.asset.model.AssetVocabulary;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the asset vocabulary service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetVocabularyPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see AssetVocabularyPersistence
038     * @see com.liferay.portlet.asset.service.persistence.impl.AssetVocabularyPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class AssetVocabularyUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(AssetVocabulary assetVocabulary) {
060                    getPersistence().clearCache(assetVocabulary);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<AssetVocabulary> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<AssetVocabulary> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<AssetVocabulary> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<AssetVocabulary> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static AssetVocabulary update(AssetVocabulary assetVocabulary) {
101                    return getPersistence().update(assetVocabulary);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static AssetVocabulary update(AssetVocabulary assetVocabulary,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(assetVocabulary, serviceContext);
110            }
111    
112            /**
113            * Returns all the asset vocabularies where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching asset vocabularies
117            */
118            public static List<AssetVocabulary> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the asset vocabularies where uuid = &#63;.
124            *
125            * <p>
126            * 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 AssetVocabularyModelImpl}. 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.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of asset vocabularies
131            * @param end the upper bound of the range of asset vocabularies (not inclusive)
132            * @return the range of matching asset vocabularies
133            */
134            public static List<AssetVocabulary> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the asset vocabularies where uuid = &#63;.
141            *
142            * <p>
143            * 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 AssetVocabularyModelImpl}. 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.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of asset vocabularies
148            * @param end the upper bound of the range of asset vocabularies (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching asset vocabularies
151            */
152            public static List<AssetVocabulary> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first asset vocabulary in the ordered set where uuid = &#63;.
159            *
160            * @param uuid the uuid
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching asset vocabulary
163            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
164            */
165            public static AssetVocabulary findByUuid_First(java.lang.String uuid,
166                    OrderByComparator<AssetVocabulary> orderByComparator)
167                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
168                    return getPersistence().findByUuid_First(uuid, orderByComparator);
169            }
170    
171            /**
172            * Returns the first asset vocabulary in the ordered set where uuid = &#63;.
173            *
174            * @param uuid the uuid
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
177            */
178            public static AssetVocabulary fetchByUuid_First(java.lang.String uuid,
179                    OrderByComparator<AssetVocabulary> orderByComparator) {
180                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the last asset vocabulary in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the last matching asset vocabulary
189            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
190            */
191            public static AssetVocabulary findByUuid_Last(java.lang.String uuid,
192                    OrderByComparator<AssetVocabulary> orderByComparator)
193                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
194                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last asset vocabulary in the ordered set where uuid = &#63;.
199            *
200            * @param uuid the uuid
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
203            */
204            public static AssetVocabulary fetchByUuid_Last(java.lang.String uuid,
205                    OrderByComparator<AssetVocabulary> orderByComparator) {
206                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
207            }
208    
209            /**
210            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = &#63;.
211            *
212            * @param vocabularyId the primary key of the current asset vocabulary
213            * @param uuid the uuid
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the previous, current, and next asset vocabulary
216            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
217            */
218            public static AssetVocabulary[] findByUuid_PrevAndNext(long vocabularyId,
219                    java.lang.String uuid,
220                    OrderByComparator<AssetVocabulary> orderByComparator)
221                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
222                    return getPersistence()
223                                       .findByUuid_PrevAndNext(vocabularyId, uuid, orderByComparator);
224            }
225    
226            /**
227            * Removes all the asset vocabularies where uuid = &#63; from the database.
228            *
229            * @param uuid the uuid
230            */
231            public static void removeByUuid(java.lang.String uuid) {
232                    getPersistence().removeByUuid(uuid);
233            }
234    
235            /**
236            * Returns the number of asset vocabularies where uuid = &#63;.
237            *
238            * @param uuid the uuid
239            * @return the number of matching asset vocabularies
240            */
241            public static int countByUuid(java.lang.String uuid) {
242                    return getPersistence().countByUuid(uuid);
243            }
244    
245            /**
246            * Returns the asset vocabulary where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchVocabularyException} if it could not be found.
247            *
248            * @param uuid the uuid
249            * @param groupId the group ID
250            * @return the matching asset vocabulary
251            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
252            */
253            public static AssetVocabulary findByUUID_G(java.lang.String uuid,
254                    long groupId)
255                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
256                    return getPersistence().findByUUID_G(uuid, groupId);
257            }
258    
259            /**
260            * Returns the asset vocabulary where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
261            *
262            * @param uuid the uuid
263            * @param groupId the group ID
264            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
265            */
266            public static AssetVocabulary fetchByUUID_G(java.lang.String uuid,
267                    long groupId) {
268                    return getPersistence().fetchByUUID_G(uuid, groupId);
269            }
270    
271            /**
272            * Returns the asset vocabulary where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
273            *
274            * @param uuid the uuid
275            * @param groupId the group ID
276            * @param retrieveFromCache whether to use the finder cache
277            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
278            */
279            public static AssetVocabulary fetchByUUID_G(java.lang.String uuid,
280                    long groupId, boolean retrieveFromCache) {
281                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
282            }
283    
284            /**
285            * Removes the asset vocabulary where uuid = &#63; and groupId = &#63; from the database.
286            *
287            * @param uuid the uuid
288            * @param groupId the group ID
289            * @return the asset vocabulary that was removed
290            */
291            public static AssetVocabulary removeByUUID_G(java.lang.String uuid,
292                    long groupId)
293                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
294                    return getPersistence().removeByUUID_G(uuid, groupId);
295            }
296    
297            /**
298            * Returns the number of asset vocabularies where uuid = &#63; and groupId = &#63;.
299            *
300            * @param uuid the uuid
301            * @param groupId the group ID
302            * @return the number of matching asset vocabularies
303            */
304            public static int countByUUID_G(java.lang.String uuid, long groupId) {
305                    return getPersistence().countByUUID_G(uuid, groupId);
306            }
307    
308            /**
309            * Returns all the asset vocabularies where uuid = &#63; and companyId = &#63;.
310            *
311            * @param uuid the uuid
312            * @param companyId the company ID
313            * @return the matching asset vocabularies
314            */
315            public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
316                    long companyId) {
317                    return getPersistence().findByUuid_C(uuid, companyId);
318            }
319    
320            /**
321            * Returns a range of all the asset vocabularies where uuid = &#63; and companyId = &#63;.
322            *
323            * <p>
324            * 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 AssetVocabularyModelImpl}. 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.
325            * </p>
326            *
327            * @param uuid the uuid
328            * @param companyId the company ID
329            * @param start the lower bound of the range of asset vocabularies
330            * @param end the upper bound of the range of asset vocabularies (not inclusive)
331            * @return the range of matching asset vocabularies
332            */
333            public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
334                    long companyId, int start, int end) {
335                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
336            }
337    
338            /**
339            * Returns an ordered range of all the asset vocabularies where uuid = &#63; and companyId = &#63;.
340            *
341            * <p>
342            * 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 AssetVocabularyModelImpl}. 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.
343            * </p>
344            *
345            * @param uuid the uuid
346            * @param companyId the company ID
347            * @param start the lower bound of the range of asset vocabularies
348            * @param end the upper bound of the range of asset vocabularies (not inclusive)
349            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
350            * @return the ordered range of matching asset vocabularies
351            */
352            public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
353                    long companyId, int start, int end,
354                    OrderByComparator<AssetVocabulary> orderByComparator) {
355                    return getPersistence()
356                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
357            }
358    
359            /**
360            * Returns the first asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
361            *
362            * @param uuid the uuid
363            * @param companyId the company ID
364            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
365            * @return the first matching asset vocabulary
366            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
367            */
368            public static AssetVocabulary findByUuid_C_First(java.lang.String uuid,
369                    long companyId, OrderByComparator<AssetVocabulary> orderByComparator)
370                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
371                    return getPersistence()
372                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
373            }
374    
375            /**
376            * Returns the first asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
377            *
378            * @param uuid the uuid
379            * @param companyId the company ID
380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
381            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
382            */
383            public static AssetVocabulary fetchByUuid_C_First(java.lang.String uuid,
384                    long companyId, OrderByComparator<AssetVocabulary> orderByComparator) {
385                    return getPersistence()
386                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
387            }
388    
389            /**
390            * Returns the last asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
391            *
392            * @param uuid the uuid
393            * @param companyId the company ID
394            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
395            * @return the last matching asset vocabulary
396            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
397            */
398            public static AssetVocabulary findByUuid_C_Last(java.lang.String uuid,
399                    long companyId, OrderByComparator<AssetVocabulary> orderByComparator)
400                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
401                    return getPersistence()
402                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
403            }
404    
405            /**
406            * Returns the last asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
407            *
408            * @param uuid the uuid
409            * @param companyId the company ID
410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
411            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
412            */
413            public static AssetVocabulary fetchByUuid_C_Last(java.lang.String uuid,
414                    long companyId, OrderByComparator<AssetVocabulary> orderByComparator) {
415                    return getPersistence()
416                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
417            }
418    
419            /**
420            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
421            *
422            * @param vocabularyId the primary key of the current asset vocabulary
423            * @param uuid the uuid
424            * @param companyId the company ID
425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
426            * @return the previous, current, and next asset vocabulary
427            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
428            */
429            public static AssetVocabulary[] findByUuid_C_PrevAndNext(
430                    long vocabularyId, java.lang.String uuid, long companyId,
431                    OrderByComparator<AssetVocabulary> orderByComparator)
432                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
433                    return getPersistence()
434                                       .findByUuid_C_PrevAndNext(vocabularyId, uuid, companyId,
435                            orderByComparator);
436            }
437    
438            /**
439            * Removes all the asset vocabularies where uuid = &#63; and companyId = &#63; from the database.
440            *
441            * @param uuid the uuid
442            * @param companyId the company ID
443            */
444            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
445                    getPersistence().removeByUuid_C(uuid, companyId);
446            }
447    
448            /**
449            * Returns the number of asset vocabularies where uuid = &#63; and companyId = &#63;.
450            *
451            * @param uuid the uuid
452            * @param companyId the company ID
453            * @return the number of matching asset vocabularies
454            */
455            public static int countByUuid_C(java.lang.String uuid, long companyId) {
456                    return getPersistence().countByUuid_C(uuid, companyId);
457            }
458    
459            /**
460            * Returns all the asset vocabularies where groupId = &#63;.
461            *
462            * @param groupId the group ID
463            * @return the matching asset vocabularies
464            */
465            public static List<AssetVocabulary> findByGroupId(long groupId) {
466                    return getPersistence().findByGroupId(groupId);
467            }
468    
469            /**
470            * Returns a range of all the asset vocabularies where groupId = &#63;.
471            *
472            * <p>
473            * 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 AssetVocabularyModelImpl}. 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.
474            * </p>
475            *
476            * @param groupId the group ID
477            * @param start the lower bound of the range of asset vocabularies
478            * @param end the upper bound of the range of asset vocabularies (not inclusive)
479            * @return the range of matching asset vocabularies
480            */
481            public static List<AssetVocabulary> findByGroupId(long groupId, int start,
482                    int end) {
483                    return getPersistence().findByGroupId(groupId, start, end);
484            }
485    
486            /**
487            * Returns an ordered range of all the asset vocabularies where groupId = &#63;.
488            *
489            * <p>
490            * 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 AssetVocabularyModelImpl}. 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.
491            * </p>
492            *
493            * @param groupId the group ID
494            * @param start the lower bound of the range of asset vocabularies
495            * @param end the upper bound of the range of asset vocabularies (not inclusive)
496            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
497            * @return the ordered range of matching asset vocabularies
498            */
499            public static List<AssetVocabulary> findByGroupId(long groupId, int start,
500                    int end, OrderByComparator<AssetVocabulary> orderByComparator) {
501                    return getPersistence()
502                                       .findByGroupId(groupId, start, end, orderByComparator);
503            }
504    
505            /**
506            * Returns the first asset vocabulary in the ordered set where groupId = &#63;.
507            *
508            * @param groupId the group ID
509            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
510            * @return the first matching asset vocabulary
511            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
512            */
513            public static AssetVocabulary findByGroupId_First(long groupId,
514                    OrderByComparator<AssetVocabulary> orderByComparator)
515                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
516                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
517            }
518    
519            /**
520            * Returns the first asset vocabulary in the ordered set where groupId = &#63;.
521            *
522            * @param groupId the group ID
523            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
524            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
525            */
526            public static AssetVocabulary fetchByGroupId_First(long groupId,
527                    OrderByComparator<AssetVocabulary> orderByComparator) {
528                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
529            }
530    
531            /**
532            * Returns the last asset vocabulary in the ordered set where groupId = &#63;.
533            *
534            * @param groupId the group ID
535            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
536            * @return the last matching asset vocabulary
537            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
538            */
539            public static AssetVocabulary findByGroupId_Last(long groupId,
540                    OrderByComparator<AssetVocabulary> orderByComparator)
541                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
542                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
543            }
544    
545            /**
546            * Returns the last asset vocabulary in the ordered set where groupId = &#63;.
547            *
548            * @param groupId the group ID
549            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
550            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
551            */
552            public static AssetVocabulary fetchByGroupId_Last(long groupId,
553                    OrderByComparator<AssetVocabulary> orderByComparator) {
554                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
555            }
556    
557            /**
558            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = &#63;.
559            *
560            * @param vocabularyId the primary key of the current asset vocabulary
561            * @param groupId the group ID
562            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
563            * @return the previous, current, and next asset vocabulary
564            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
565            */
566            public static AssetVocabulary[] findByGroupId_PrevAndNext(
567                    long vocabularyId, long groupId,
568                    OrderByComparator<AssetVocabulary> orderByComparator)
569                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
570                    return getPersistence()
571                                       .findByGroupId_PrevAndNext(vocabularyId, groupId,
572                            orderByComparator);
573            }
574    
575            /**
576            * Returns all the asset vocabularies that the user has permission to view where groupId = &#63;.
577            *
578            * @param groupId the group ID
579            * @return the matching asset vocabularies that the user has permission to view
580            */
581            public static List<AssetVocabulary> filterFindByGroupId(long groupId) {
582                    return getPersistence().filterFindByGroupId(groupId);
583            }
584    
585            /**
586            * Returns a range of all the asset vocabularies that the user has permission to view where groupId = &#63;.
587            *
588            * <p>
589            * 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 AssetVocabularyModelImpl}. 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.
590            * </p>
591            *
592            * @param groupId the group ID
593            * @param start the lower bound of the range of asset vocabularies
594            * @param end the upper bound of the range of asset vocabularies (not inclusive)
595            * @return the range of matching asset vocabularies that the user has permission to view
596            */
597            public static List<AssetVocabulary> filterFindByGroupId(long groupId,
598                    int start, int end) {
599                    return getPersistence().filterFindByGroupId(groupId, start, end);
600            }
601    
602            /**
603            * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = &#63;.
604            *
605            * <p>
606            * 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 AssetVocabularyModelImpl}. 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.
607            * </p>
608            *
609            * @param groupId the group ID
610            * @param start the lower bound of the range of asset vocabularies
611            * @param end the upper bound of the range of asset vocabularies (not inclusive)
612            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
613            * @return the ordered range of matching asset vocabularies that the user has permission to view
614            */
615            public static List<AssetVocabulary> filterFindByGroupId(long groupId,
616                    int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) {
617                    return getPersistence()
618                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
619            }
620    
621            /**
622            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set of asset vocabularies that the user has permission to view where groupId = &#63;.
623            *
624            * @param vocabularyId the primary key of the current asset vocabulary
625            * @param groupId the group ID
626            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
627            * @return the previous, current, and next asset vocabulary
628            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
629            */
630            public static AssetVocabulary[] filterFindByGroupId_PrevAndNext(
631                    long vocabularyId, long groupId,
632                    OrderByComparator<AssetVocabulary> orderByComparator)
633                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
634                    return getPersistence()
635                                       .filterFindByGroupId_PrevAndNext(vocabularyId, groupId,
636                            orderByComparator);
637            }
638    
639            /**
640            * Returns all the asset vocabularies that the user has permission to view where groupId = any &#63;.
641            *
642            * @param groupIds the group IDs
643            * @return the matching asset vocabularies that the user has permission to view
644            */
645            public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds) {
646                    return getPersistence().filterFindByGroupId(groupIds);
647            }
648    
649            /**
650            * Returns a range of all the asset vocabularies that the user has permission to view where groupId = any &#63;.
651            *
652            * <p>
653            * 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 AssetVocabularyModelImpl}. 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.
654            * </p>
655            *
656            * @param groupIds the group IDs
657            * @param start the lower bound of the range of asset vocabularies
658            * @param end the upper bound of the range of asset vocabularies (not inclusive)
659            * @return the range of matching asset vocabularies that the user has permission to view
660            */
661            public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds,
662                    int start, int end) {
663                    return getPersistence().filterFindByGroupId(groupIds, start, end);
664            }
665    
666            /**
667            * Returns an ordered range of all the asset vocabularies that the user has permission to view where groupId = any &#63;.
668            *
669            * <p>
670            * 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 AssetVocabularyModelImpl}. 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.
671            * </p>
672            *
673            * @param groupIds the group IDs
674            * @param start the lower bound of the range of asset vocabularies
675            * @param end the upper bound of the range of asset vocabularies (not inclusive)
676            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
677            * @return the ordered range of matching asset vocabularies that the user has permission to view
678            */
679            public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds,
680                    int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) {
681                    return getPersistence()
682                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
683            }
684    
685            /**
686            * Returns all the asset vocabularies where groupId = any &#63;.
687            *
688            * <p>
689            * 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 AssetVocabularyModelImpl}. 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.
690            * </p>
691            *
692            * @param groupIds the group IDs
693            * @return the matching asset vocabularies
694            */
695            public static List<AssetVocabulary> findByGroupId(long[] groupIds) {
696                    return getPersistence().findByGroupId(groupIds);
697            }
698    
699            /**
700            * Returns a range of all the asset vocabularies where groupId = any &#63;.
701            *
702            * <p>
703            * 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 AssetVocabularyModelImpl}. 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.
704            * </p>
705            *
706            * @param groupIds the group IDs
707            * @param start the lower bound of the range of asset vocabularies
708            * @param end the upper bound of the range of asset vocabularies (not inclusive)
709            * @return the range of matching asset vocabularies
710            */
711            public static List<AssetVocabulary> findByGroupId(long[] groupIds,
712                    int start, int end) {
713                    return getPersistence().findByGroupId(groupIds, start, end);
714            }
715    
716            /**
717            * Returns an ordered range of all the asset vocabularies where groupId = any &#63;.
718            *
719            * <p>
720            * 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 AssetVocabularyModelImpl}. 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.
721            * </p>
722            *
723            * @param groupIds the group IDs
724            * @param start the lower bound of the range of asset vocabularies
725            * @param end the upper bound of the range of asset vocabularies (not inclusive)
726            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
727            * @return the ordered range of matching asset vocabularies
728            */
729            public static List<AssetVocabulary> findByGroupId(long[] groupIds,
730                    int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) {
731                    return getPersistence()
732                                       .findByGroupId(groupIds, start, end, orderByComparator);
733            }
734    
735            /**
736            * Removes all the asset vocabularies where groupId = &#63; from the database.
737            *
738            * @param groupId the group ID
739            */
740            public static void removeByGroupId(long groupId) {
741                    getPersistence().removeByGroupId(groupId);
742            }
743    
744            /**
745            * Returns the number of asset vocabularies where groupId = &#63;.
746            *
747            * @param groupId the group ID
748            * @return the number of matching asset vocabularies
749            */
750            public static int countByGroupId(long groupId) {
751                    return getPersistence().countByGroupId(groupId);
752            }
753    
754            /**
755            * Returns the number of asset vocabularies where groupId = any &#63;.
756            *
757            * @param groupIds the group IDs
758            * @return the number of matching asset vocabularies
759            */
760            public static int countByGroupId(long[] groupIds) {
761                    return getPersistence().countByGroupId(groupIds);
762            }
763    
764            /**
765            * Returns the number of asset vocabularies that the user has permission to view where groupId = &#63;.
766            *
767            * @param groupId the group ID
768            * @return the number of matching asset vocabularies that the user has permission to view
769            */
770            public static int filterCountByGroupId(long groupId) {
771                    return getPersistence().filterCountByGroupId(groupId);
772            }
773    
774            /**
775            * Returns the number of asset vocabularies that the user has permission to view where groupId = any &#63;.
776            *
777            * @param groupIds the group IDs
778            * @return the number of matching asset vocabularies that the user has permission to view
779            */
780            public static int filterCountByGroupId(long[] groupIds) {
781                    return getPersistence().filterCountByGroupId(groupIds);
782            }
783    
784            /**
785            * Returns all the asset vocabularies where companyId = &#63;.
786            *
787            * @param companyId the company ID
788            * @return the matching asset vocabularies
789            */
790            public static List<AssetVocabulary> findByCompanyId(long companyId) {
791                    return getPersistence().findByCompanyId(companyId);
792            }
793    
794            /**
795            * Returns a range of all the asset vocabularies where companyId = &#63;.
796            *
797            * <p>
798            * 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 AssetVocabularyModelImpl}. 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.
799            * </p>
800            *
801            * @param companyId the company ID
802            * @param start the lower bound of the range of asset vocabularies
803            * @param end the upper bound of the range of asset vocabularies (not inclusive)
804            * @return the range of matching asset vocabularies
805            */
806            public static List<AssetVocabulary> findByCompanyId(long companyId,
807                    int start, int end) {
808                    return getPersistence().findByCompanyId(companyId, start, end);
809            }
810    
811            /**
812            * Returns an ordered range of all the asset vocabularies where companyId = &#63;.
813            *
814            * <p>
815            * 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 AssetVocabularyModelImpl}. 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.
816            * </p>
817            *
818            * @param companyId the company ID
819            * @param start the lower bound of the range of asset vocabularies
820            * @param end the upper bound of the range of asset vocabularies (not inclusive)
821            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
822            * @return the ordered range of matching asset vocabularies
823            */
824            public static List<AssetVocabulary> findByCompanyId(long companyId,
825                    int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) {
826                    return getPersistence()
827                                       .findByCompanyId(companyId, start, end, orderByComparator);
828            }
829    
830            /**
831            * Returns the first asset vocabulary in the ordered set where companyId = &#63;.
832            *
833            * @param companyId the company ID
834            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
835            * @return the first matching asset vocabulary
836            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
837            */
838            public static AssetVocabulary findByCompanyId_First(long companyId,
839                    OrderByComparator<AssetVocabulary> orderByComparator)
840                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
841                    return getPersistence()
842                                       .findByCompanyId_First(companyId, orderByComparator);
843            }
844    
845            /**
846            * Returns the first asset vocabulary in the ordered set where companyId = &#63;.
847            *
848            * @param companyId the company ID
849            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
850            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
851            */
852            public static AssetVocabulary fetchByCompanyId_First(long companyId,
853                    OrderByComparator<AssetVocabulary> orderByComparator) {
854                    return getPersistence()
855                                       .fetchByCompanyId_First(companyId, orderByComparator);
856            }
857    
858            /**
859            * Returns the last asset vocabulary in the ordered set where companyId = &#63;.
860            *
861            * @param companyId the company ID
862            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
863            * @return the last matching asset vocabulary
864            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
865            */
866            public static AssetVocabulary findByCompanyId_Last(long companyId,
867                    OrderByComparator<AssetVocabulary> orderByComparator)
868                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
869                    return getPersistence()
870                                       .findByCompanyId_Last(companyId, orderByComparator);
871            }
872    
873            /**
874            * Returns the last asset vocabulary in the ordered set where companyId = &#63;.
875            *
876            * @param companyId the company ID
877            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
878            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
879            */
880            public static AssetVocabulary fetchByCompanyId_Last(long companyId,
881                    OrderByComparator<AssetVocabulary> orderByComparator) {
882                    return getPersistence()
883                                       .fetchByCompanyId_Last(companyId, orderByComparator);
884            }
885    
886            /**
887            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where companyId = &#63;.
888            *
889            * @param vocabularyId the primary key of the current asset vocabulary
890            * @param companyId the company ID
891            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
892            * @return the previous, current, and next asset vocabulary
893            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
894            */
895            public static AssetVocabulary[] findByCompanyId_PrevAndNext(
896                    long vocabularyId, long companyId,
897                    OrderByComparator<AssetVocabulary> orderByComparator)
898                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
899                    return getPersistence()
900                                       .findByCompanyId_PrevAndNext(vocabularyId, companyId,
901                            orderByComparator);
902            }
903    
904            /**
905            * Removes all the asset vocabularies where companyId = &#63; from the database.
906            *
907            * @param companyId the company ID
908            */
909            public static void removeByCompanyId(long companyId) {
910                    getPersistence().removeByCompanyId(companyId);
911            }
912    
913            /**
914            * Returns the number of asset vocabularies where companyId = &#63;.
915            *
916            * @param companyId the company ID
917            * @return the number of matching asset vocabularies
918            */
919            public static int countByCompanyId(long companyId) {
920                    return getPersistence().countByCompanyId(companyId);
921            }
922    
923            /**
924            * Returns the asset vocabulary where groupId = &#63; and name = &#63; or throws a {@link NoSuchVocabularyException} if it could not be found.
925            *
926            * @param groupId the group ID
927            * @param name the name
928            * @return the matching asset vocabulary
929            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
930            */
931            public static AssetVocabulary findByG_N(long groupId, java.lang.String name)
932                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
933                    return getPersistence().findByG_N(groupId, name);
934            }
935    
936            /**
937            * Returns the asset vocabulary where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
938            *
939            * @param groupId the group ID
940            * @param name the name
941            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
942            */
943            public static AssetVocabulary fetchByG_N(long groupId, java.lang.String name) {
944                    return getPersistence().fetchByG_N(groupId, name);
945            }
946    
947            /**
948            * Returns the asset vocabulary where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
949            *
950            * @param groupId the group ID
951            * @param name the name
952            * @param retrieveFromCache whether to use the finder cache
953            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
954            */
955            public static AssetVocabulary fetchByG_N(long groupId,
956                    java.lang.String name, boolean retrieveFromCache) {
957                    return getPersistence().fetchByG_N(groupId, name, retrieveFromCache);
958            }
959    
960            /**
961            * Removes the asset vocabulary where groupId = &#63; and name = &#63; from the database.
962            *
963            * @param groupId the group ID
964            * @param name the name
965            * @return the asset vocabulary that was removed
966            */
967            public static AssetVocabulary removeByG_N(long groupId,
968                    java.lang.String name)
969                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
970                    return getPersistence().removeByG_N(groupId, name);
971            }
972    
973            /**
974            * Returns the number of asset vocabularies where groupId = &#63; and name = &#63;.
975            *
976            * @param groupId the group ID
977            * @param name the name
978            * @return the number of matching asset vocabularies
979            */
980            public static int countByG_N(long groupId, java.lang.String name) {
981                    return getPersistence().countByG_N(groupId, name);
982            }
983    
984            /**
985            * Returns all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
986            *
987            * @param groupId the group ID
988            * @param name the name
989            * @return the matching asset vocabularies
990            */
991            public static List<AssetVocabulary> findByG_LikeN(long groupId,
992                    java.lang.String name) {
993                    return getPersistence().findByG_LikeN(groupId, name);
994            }
995    
996            /**
997            * Returns a range of all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
998            *
999            * <p>
1000            * 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 AssetVocabularyModelImpl}. 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.
1001            * </p>
1002            *
1003            * @param groupId the group ID
1004            * @param name the name
1005            * @param start the lower bound of the range of asset vocabularies
1006            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1007            * @return the range of matching asset vocabularies
1008            */
1009            public static List<AssetVocabulary> findByG_LikeN(long groupId,
1010                    java.lang.String name, int start, int end) {
1011                    return getPersistence().findByG_LikeN(groupId, name, start, end);
1012            }
1013    
1014            /**
1015            * Returns an ordered range of all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
1016            *
1017            * <p>
1018            * 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 AssetVocabularyModelImpl}. 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.
1019            * </p>
1020            *
1021            * @param groupId the group ID
1022            * @param name the name
1023            * @param start the lower bound of the range of asset vocabularies
1024            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1025            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1026            * @return the ordered range of matching asset vocabularies
1027            */
1028            public static List<AssetVocabulary> findByG_LikeN(long groupId,
1029                    java.lang.String name, int start, int end,
1030                    OrderByComparator<AssetVocabulary> orderByComparator) {
1031                    return getPersistence()
1032                                       .findByG_LikeN(groupId, name, start, end, orderByComparator);
1033            }
1034    
1035            /**
1036            * Returns the first asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
1037            *
1038            * @param groupId the group ID
1039            * @param name the name
1040            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1041            * @return the first matching asset vocabulary
1042            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
1043            */
1044            public static AssetVocabulary findByG_LikeN_First(long groupId,
1045                    java.lang.String name,
1046                    OrderByComparator<AssetVocabulary> orderByComparator)
1047                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
1048                    return getPersistence()
1049                                       .findByG_LikeN_First(groupId, name, orderByComparator);
1050            }
1051    
1052            /**
1053            * Returns the first asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
1054            *
1055            * @param groupId the group ID
1056            * @param name the name
1057            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1058            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
1059            */
1060            public static AssetVocabulary fetchByG_LikeN_First(long groupId,
1061                    java.lang.String name,
1062                    OrderByComparator<AssetVocabulary> orderByComparator) {
1063                    return getPersistence()
1064                                       .fetchByG_LikeN_First(groupId, name, orderByComparator);
1065            }
1066    
1067            /**
1068            * Returns the last asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
1069            *
1070            * @param groupId the group ID
1071            * @param name the name
1072            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1073            * @return the last matching asset vocabulary
1074            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
1075            */
1076            public static AssetVocabulary findByG_LikeN_Last(long groupId,
1077                    java.lang.String name,
1078                    OrderByComparator<AssetVocabulary> orderByComparator)
1079                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
1080                    return getPersistence()
1081                                       .findByG_LikeN_Last(groupId, name, orderByComparator);
1082            }
1083    
1084            /**
1085            * Returns the last asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
1086            *
1087            * @param groupId the group ID
1088            * @param name the name
1089            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1090            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
1091            */
1092            public static AssetVocabulary fetchByG_LikeN_Last(long groupId,
1093                    java.lang.String name,
1094                    OrderByComparator<AssetVocabulary> orderByComparator) {
1095                    return getPersistence()
1096                                       .fetchByG_LikeN_Last(groupId, name, orderByComparator);
1097            }
1098    
1099            /**
1100            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
1101            *
1102            * @param vocabularyId the primary key of the current asset vocabulary
1103            * @param groupId the group ID
1104            * @param name the name
1105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1106            * @return the previous, current, and next asset vocabulary
1107            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1108            */
1109            public static AssetVocabulary[] findByG_LikeN_PrevAndNext(
1110                    long vocabularyId, long groupId, java.lang.String name,
1111                    OrderByComparator<AssetVocabulary> orderByComparator)
1112                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
1113                    return getPersistence()
1114                                       .findByG_LikeN_PrevAndNext(vocabularyId, groupId, name,
1115                            orderByComparator);
1116            }
1117    
1118            /**
1119            * Returns all the asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1120            *
1121            * @param groupId the group ID
1122            * @param name the name
1123            * @return the matching asset vocabularies that the user has permission to view
1124            */
1125            public static List<AssetVocabulary> filterFindByG_LikeN(long groupId,
1126                    java.lang.String name) {
1127                    return getPersistence().filterFindByG_LikeN(groupId, name);
1128            }
1129    
1130            /**
1131            * Returns a range of all the asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1132            *
1133            * <p>
1134            * 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 AssetVocabularyModelImpl}. 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.
1135            * </p>
1136            *
1137            * @param groupId the group ID
1138            * @param name the name
1139            * @param start the lower bound of the range of asset vocabularies
1140            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1141            * @return the range of matching asset vocabularies that the user has permission to view
1142            */
1143            public static List<AssetVocabulary> filterFindByG_LikeN(long groupId,
1144                    java.lang.String name, int start, int end) {
1145                    return getPersistence().filterFindByG_LikeN(groupId, name, start, end);
1146            }
1147    
1148            /**
1149            * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = &#63; and name LIKE &#63;.
1150            *
1151            * <p>
1152            * 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 AssetVocabularyModelImpl}. 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.
1153            * </p>
1154            *
1155            * @param groupId the group ID
1156            * @param name the name
1157            * @param start the lower bound of the range of asset vocabularies
1158            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1159            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1160            * @return the ordered range of matching asset vocabularies that the user has permission to view
1161            */
1162            public static List<AssetVocabulary> filterFindByG_LikeN(long groupId,
1163                    java.lang.String name, int start, int end,
1164                    OrderByComparator<AssetVocabulary> orderByComparator) {
1165                    return getPersistence()
1166                                       .filterFindByG_LikeN(groupId, name, start, end,
1167                            orderByComparator);
1168            }
1169    
1170            /**
1171            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set of asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1172            *
1173            * @param vocabularyId the primary key of the current asset vocabulary
1174            * @param groupId the group ID
1175            * @param name the name
1176            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1177            * @return the previous, current, and next asset vocabulary
1178            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1179            */
1180            public static AssetVocabulary[] filterFindByG_LikeN_PrevAndNext(
1181                    long vocabularyId, long groupId, java.lang.String name,
1182                    OrderByComparator<AssetVocabulary> orderByComparator)
1183                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
1184                    return getPersistence()
1185                                       .filterFindByG_LikeN_PrevAndNext(vocabularyId, groupId,
1186                            name, orderByComparator);
1187            }
1188    
1189            /**
1190            * Removes all the asset vocabularies where groupId = &#63; and name LIKE &#63; from the database.
1191            *
1192            * @param groupId the group ID
1193            * @param name the name
1194            */
1195            public static void removeByG_LikeN(long groupId, java.lang.String name) {
1196                    getPersistence().removeByG_LikeN(groupId, name);
1197            }
1198    
1199            /**
1200            * Returns the number of asset vocabularies where groupId = &#63; and name LIKE &#63;.
1201            *
1202            * @param groupId the group ID
1203            * @param name the name
1204            * @return the number of matching asset vocabularies
1205            */
1206            public static int countByG_LikeN(long groupId, java.lang.String name) {
1207                    return getPersistence().countByG_LikeN(groupId, name);
1208            }
1209    
1210            /**
1211            * Returns the number of asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1212            *
1213            * @param groupId the group ID
1214            * @param name the name
1215            * @return the number of matching asset vocabularies that the user has permission to view
1216            */
1217            public static int filterCountByG_LikeN(long groupId, java.lang.String name) {
1218                    return getPersistence().filterCountByG_LikeN(groupId, name);
1219            }
1220    
1221            /**
1222            * Caches the asset vocabulary in the entity cache if it is enabled.
1223            *
1224            * @param assetVocabulary the asset vocabulary
1225            */
1226            public static void cacheResult(AssetVocabulary assetVocabulary) {
1227                    getPersistence().cacheResult(assetVocabulary);
1228            }
1229    
1230            /**
1231            * Caches the asset vocabularies in the entity cache if it is enabled.
1232            *
1233            * @param assetVocabularies the asset vocabularies
1234            */
1235            public static void cacheResult(List<AssetVocabulary> assetVocabularies) {
1236                    getPersistence().cacheResult(assetVocabularies);
1237            }
1238    
1239            /**
1240            * Creates a new asset vocabulary with the primary key. Does not add the asset vocabulary to the database.
1241            *
1242            * @param vocabularyId the primary key for the new asset vocabulary
1243            * @return the new asset vocabulary
1244            */
1245            public static AssetVocabulary create(long vocabularyId) {
1246                    return getPersistence().create(vocabularyId);
1247            }
1248    
1249            /**
1250            * Removes the asset vocabulary with the primary key from the database. Also notifies the appropriate model listeners.
1251            *
1252            * @param vocabularyId the primary key of the asset vocabulary
1253            * @return the asset vocabulary that was removed
1254            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1255            */
1256            public static AssetVocabulary remove(long vocabularyId)
1257                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
1258                    return getPersistence().remove(vocabularyId);
1259            }
1260    
1261            public static AssetVocabulary updateImpl(AssetVocabulary assetVocabulary) {
1262                    return getPersistence().updateImpl(assetVocabulary);
1263            }
1264    
1265            /**
1266            * Returns the asset vocabulary with the primary key or throws a {@link NoSuchVocabularyException} if it could not be found.
1267            *
1268            * @param vocabularyId the primary key of the asset vocabulary
1269            * @return the asset vocabulary
1270            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1271            */
1272            public static AssetVocabulary findByPrimaryKey(long vocabularyId)
1273                    throws com.liferay.portlet.asset.NoSuchVocabularyException {
1274                    return getPersistence().findByPrimaryKey(vocabularyId);
1275            }
1276    
1277            /**
1278            * Returns the asset vocabulary with the primary key or returns <code>null</code> if it could not be found.
1279            *
1280            * @param vocabularyId the primary key of the asset vocabulary
1281            * @return the asset vocabulary, or <code>null</code> if a asset vocabulary with the primary key could not be found
1282            */
1283            public static AssetVocabulary fetchByPrimaryKey(long vocabularyId) {
1284                    return getPersistence().fetchByPrimaryKey(vocabularyId);
1285            }
1286    
1287            public static java.util.Map<java.io.Serializable, AssetVocabulary> fetchByPrimaryKeys(
1288                    java.util.Set<java.io.Serializable> primaryKeys) {
1289                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1290            }
1291    
1292            /**
1293            * Returns all the asset vocabularies.
1294            *
1295            * @return the asset vocabularies
1296            */
1297            public static List<AssetVocabulary> findAll() {
1298                    return getPersistence().findAll();
1299            }
1300    
1301            /**
1302            * Returns a range of all the asset vocabularies.
1303            *
1304            * <p>
1305            * 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 AssetVocabularyModelImpl}. 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.
1306            * </p>
1307            *
1308            * @param start the lower bound of the range of asset vocabularies
1309            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1310            * @return the range of asset vocabularies
1311            */
1312            public static List<AssetVocabulary> findAll(int start, int end) {
1313                    return getPersistence().findAll(start, end);
1314            }
1315    
1316            /**
1317            * Returns an ordered range of all the asset vocabularies.
1318            *
1319            * <p>
1320            * 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 AssetVocabularyModelImpl}. 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.
1321            * </p>
1322            *
1323            * @param start the lower bound of the range of asset vocabularies
1324            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1325            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1326            * @return the ordered range of asset vocabularies
1327            */
1328            public static List<AssetVocabulary> findAll(int start, int end,
1329                    OrderByComparator<AssetVocabulary> orderByComparator) {
1330                    return getPersistence().findAll(start, end, orderByComparator);
1331            }
1332    
1333            /**
1334            * Removes all the asset vocabularies from the database.
1335            */
1336            public static void removeAll() {
1337                    getPersistence().removeAll();
1338            }
1339    
1340            /**
1341            * Returns the number of asset vocabularies.
1342            *
1343            * @return the number of asset vocabularies
1344            */
1345            public static int countAll() {
1346                    return getPersistence().countAll();
1347            }
1348    
1349            public static AssetVocabularyPersistence getPersistence() {
1350                    if (_persistence == null) {
1351                            _persistence = (AssetVocabularyPersistence)PortalBeanLocatorUtil.locate(AssetVocabularyPersistence.class.getName());
1352    
1353                            ReferenceRegistry.registerReference(AssetVocabularyUtil.class,
1354                                    "_persistence");
1355                    }
1356    
1357                    return _persistence;
1358            }
1359    
1360            /**
1361             * @deprecated As of 6.2.0
1362             */
1363            @Deprecated
1364            public void setPersistence(AssetVocabularyPersistence persistence) {
1365            }
1366    
1367            private static AssetVocabularyPersistence _persistence;
1368    }