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 an ordered range of all the asset vocabularies where uuid = &#63;.
159            *
160            * <p>
161            * 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.
162            * </p>
163            *
164            * @param uuid the uuid
165            * @param start the lower bound of the range of asset vocabularies
166            * @param end the upper bound of the range of asset vocabularies (not inclusive)
167            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
168            * @param retrieveFromCache whether to retrieve from the finder cache
169            * @return the ordered range of matching asset vocabularies
170            */
171            public static List<AssetVocabulary> findByUuid(java.lang.String uuid,
172                    int start, int end,
173                    OrderByComparator<AssetVocabulary> orderByComparator,
174                    boolean retrieveFromCache) {
175                    return getPersistence()
176                                       .findByUuid(uuid, start, end, orderByComparator,
177                            retrieveFromCache);
178            }
179    
180            /**
181            * Returns the first asset vocabulary in the ordered set where uuid = &#63;.
182            *
183            * @param uuid the uuid
184            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
185            * @return the first matching asset vocabulary
186            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
187            */
188            public static AssetVocabulary findByUuid_First(java.lang.String uuid,
189                    OrderByComparator<AssetVocabulary> orderByComparator)
190                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
191                    return getPersistence().findByUuid_First(uuid, orderByComparator);
192            }
193    
194            /**
195            * Returns the first asset vocabulary in the ordered set where uuid = &#63;.
196            *
197            * @param uuid the uuid
198            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
199            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
200            */
201            public static AssetVocabulary fetchByUuid_First(java.lang.String uuid,
202                    OrderByComparator<AssetVocabulary> orderByComparator) {
203                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
204            }
205    
206            /**
207            * Returns the last asset vocabulary in the ordered set where uuid = &#63;.
208            *
209            * @param uuid the uuid
210            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
211            * @return the last matching asset vocabulary
212            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
213            */
214            public static AssetVocabulary findByUuid_Last(java.lang.String uuid,
215                    OrderByComparator<AssetVocabulary> orderByComparator)
216                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
217                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
218            }
219    
220            /**
221            * Returns the last asset vocabulary in the ordered set where uuid = &#63;.
222            *
223            * @param uuid the uuid
224            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
225            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
226            */
227            public static AssetVocabulary fetchByUuid_Last(java.lang.String uuid,
228                    OrderByComparator<AssetVocabulary> orderByComparator) {
229                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
230            }
231    
232            /**
233            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = &#63;.
234            *
235            * @param vocabularyId the primary key of the current asset vocabulary
236            * @param uuid the uuid
237            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
238            * @return the previous, current, and next asset vocabulary
239            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
240            */
241            public static AssetVocabulary[] findByUuid_PrevAndNext(long vocabularyId,
242                    java.lang.String uuid,
243                    OrderByComparator<AssetVocabulary> orderByComparator)
244                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
245                    return getPersistence()
246                                       .findByUuid_PrevAndNext(vocabularyId, uuid, orderByComparator);
247            }
248    
249            /**
250            * Removes all the asset vocabularies where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            */
254            public static void removeByUuid(java.lang.String uuid) {
255                    getPersistence().removeByUuid(uuid);
256            }
257    
258            /**
259            * Returns the number of asset vocabularies where uuid = &#63;.
260            *
261            * @param uuid the uuid
262            * @return the number of matching asset vocabularies
263            */
264            public static int countByUuid(java.lang.String uuid) {
265                    return getPersistence().countByUuid(uuid);
266            }
267    
268            /**
269            * Returns the asset vocabulary where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchVocabularyException} if it could not be found.
270            *
271            * @param uuid the uuid
272            * @param groupId the group ID
273            * @return the matching asset vocabulary
274            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
275            */
276            public static AssetVocabulary findByUUID_G(java.lang.String uuid,
277                    long groupId)
278                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
279                    return getPersistence().findByUUID_G(uuid, groupId);
280            }
281    
282            /**
283            * 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.
284            *
285            * @param uuid the uuid
286            * @param groupId the group ID
287            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
288            */
289            public static AssetVocabulary fetchByUUID_G(java.lang.String uuid,
290                    long groupId) {
291                    return getPersistence().fetchByUUID_G(uuid, groupId);
292            }
293    
294            /**
295            * 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.
296            *
297            * @param uuid the uuid
298            * @param groupId the group ID
299            * @param retrieveFromCache whether to retrieve from the finder cache
300            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
301            */
302            public static AssetVocabulary fetchByUUID_G(java.lang.String uuid,
303                    long groupId, boolean retrieveFromCache) {
304                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
305            }
306    
307            /**
308            * Removes the asset vocabulary where uuid = &#63; and groupId = &#63; from the database.
309            *
310            * @param uuid the uuid
311            * @param groupId the group ID
312            * @return the asset vocabulary that was removed
313            */
314            public static AssetVocabulary removeByUUID_G(java.lang.String uuid,
315                    long groupId)
316                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
317                    return getPersistence().removeByUUID_G(uuid, groupId);
318            }
319    
320            /**
321            * Returns the number of asset vocabularies where uuid = &#63; and groupId = &#63;.
322            *
323            * @param uuid the uuid
324            * @param groupId the group ID
325            * @return the number of matching asset vocabularies
326            */
327            public static int countByUUID_G(java.lang.String uuid, long groupId) {
328                    return getPersistence().countByUUID_G(uuid, groupId);
329            }
330    
331            /**
332            * Returns all the asset vocabularies where uuid = &#63; and companyId = &#63;.
333            *
334            * @param uuid the uuid
335            * @param companyId the company ID
336            * @return the matching asset vocabularies
337            */
338            public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
339                    long companyId) {
340                    return getPersistence().findByUuid_C(uuid, companyId);
341            }
342    
343            /**
344            * Returns a range of all the asset vocabularies where uuid = &#63; and companyId = &#63;.
345            *
346            * <p>
347            * 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.
348            * </p>
349            *
350            * @param uuid the uuid
351            * @param companyId the company ID
352            * @param start the lower bound of the range of asset vocabularies
353            * @param end the upper bound of the range of asset vocabularies (not inclusive)
354            * @return the range of matching asset vocabularies
355            */
356            public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
357                    long companyId, int start, int end) {
358                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
359            }
360    
361            /**
362            * Returns an ordered range of all the asset vocabularies where uuid = &#63; and companyId = &#63;.
363            *
364            * <p>
365            * 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.
366            * </p>
367            *
368            * @param uuid the uuid
369            * @param companyId the company ID
370            * @param start the lower bound of the range of asset vocabularies
371            * @param end the upper bound of the range of asset vocabularies (not inclusive)
372            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
373            * @return the ordered range of matching asset vocabularies
374            */
375            public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
376                    long companyId, int start, int end,
377                    OrderByComparator<AssetVocabulary> orderByComparator) {
378                    return getPersistence()
379                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
380            }
381    
382            /**
383            * Returns an ordered range of all the asset vocabularies where uuid = &#63; and companyId = &#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 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.
387            * </p>
388            *
389            * @param uuid the uuid
390            * @param companyId the company ID
391            * @param start the lower bound of the range of asset vocabularies
392            * @param end the upper bound of the range of asset vocabularies (not inclusive)
393            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
394            * @param retrieveFromCache whether to retrieve from the finder cache
395            * @return the ordered range of matching asset vocabularies
396            */
397            public static List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
398                    long companyId, int start, int end,
399                    OrderByComparator<AssetVocabulary> orderByComparator,
400                    boolean retrieveFromCache) {
401                    return getPersistence()
402                                       .findByUuid_C(uuid, companyId, start, end,
403                            orderByComparator, retrieveFromCache);
404            }
405    
406            /**
407            * Returns the first asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
408            *
409            * @param uuid the uuid
410            * @param companyId the company ID
411            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
412            * @return the first matching asset vocabulary
413            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
414            */
415            public static AssetVocabulary findByUuid_C_First(java.lang.String uuid,
416                    long companyId, OrderByComparator<AssetVocabulary> orderByComparator)
417                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
418                    return getPersistence()
419                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
420            }
421    
422            /**
423            * Returns the first asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
424            *
425            * @param uuid the uuid
426            * @param companyId the company ID
427            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
428            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
429            */
430            public static AssetVocabulary fetchByUuid_C_First(java.lang.String uuid,
431                    long companyId, OrderByComparator<AssetVocabulary> orderByComparator) {
432                    return getPersistence()
433                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
434            }
435    
436            /**
437            * Returns the last asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
438            *
439            * @param uuid the uuid
440            * @param companyId the company ID
441            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
442            * @return the last matching asset vocabulary
443            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
444            */
445            public static AssetVocabulary findByUuid_C_Last(java.lang.String uuid,
446                    long companyId, OrderByComparator<AssetVocabulary> orderByComparator)
447                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
448                    return getPersistence()
449                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
450            }
451    
452            /**
453            * Returns the last asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
454            *
455            * @param uuid the uuid
456            * @param companyId the company ID
457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
458            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
459            */
460            public static AssetVocabulary fetchByUuid_C_Last(java.lang.String uuid,
461                    long companyId, OrderByComparator<AssetVocabulary> orderByComparator) {
462                    return getPersistence()
463                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
464            }
465    
466            /**
467            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
468            *
469            * @param vocabularyId the primary key of the current asset vocabulary
470            * @param uuid the uuid
471            * @param companyId the company ID
472            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
473            * @return the previous, current, and next asset vocabulary
474            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
475            */
476            public static AssetVocabulary[] findByUuid_C_PrevAndNext(
477                    long vocabularyId, java.lang.String uuid, long companyId,
478                    OrderByComparator<AssetVocabulary> orderByComparator)
479                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
480                    return getPersistence()
481                                       .findByUuid_C_PrevAndNext(vocabularyId, uuid, companyId,
482                            orderByComparator);
483            }
484    
485            /**
486            * Removes all the asset vocabularies where uuid = &#63; and companyId = &#63; from the database.
487            *
488            * @param uuid the uuid
489            * @param companyId the company ID
490            */
491            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
492                    getPersistence().removeByUuid_C(uuid, companyId);
493            }
494    
495            /**
496            * Returns the number of asset vocabularies where uuid = &#63; and companyId = &#63;.
497            *
498            * @param uuid the uuid
499            * @param companyId the company ID
500            * @return the number of matching asset vocabularies
501            */
502            public static int countByUuid_C(java.lang.String uuid, long companyId) {
503                    return getPersistence().countByUuid_C(uuid, companyId);
504            }
505    
506            /**
507            * Returns all the asset vocabularies where groupId = &#63;.
508            *
509            * @param groupId the group ID
510            * @return the matching asset vocabularies
511            */
512            public static List<AssetVocabulary> findByGroupId(long groupId) {
513                    return getPersistence().findByGroupId(groupId);
514            }
515    
516            /**
517            * Returns a range of all the asset vocabularies where groupId = &#63;.
518            *
519            * <p>
520            * 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.
521            * </p>
522            *
523            * @param groupId the group ID
524            * @param start the lower bound of the range of asset vocabularies
525            * @param end the upper bound of the range of asset vocabularies (not inclusive)
526            * @return the range of matching asset vocabularies
527            */
528            public static List<AssetVocabulary> findByGroupId(long groupId, int start,
529                    int end) {
530                    return getPersistence().findByGroupId(groupId, start, end);
531            }
532    
533            /**
534            * Returns an ordered range of all the asset vocabularies where groupId = &#63;.
535            *
536            * <p>
537            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.
538            * </p>
539            *
540            * @param groupId the group ID
541            * @param start the lower bound of the range of asset vocabularies
542            * @param end the upper bound of the range of asset vocabularies (not inclusive)
543            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
544            * @return the ordered range of matching asset vocabularies
545            */
546            public static List<AssetVocabulary> findByGroupId(long groupId, int start,
547                    int end, OrderByComparator<AssetVocabulary> orderByComparator) {
548                    return getPersistence()
549                                       .findByGroupId(groupId, start, end, orderByComparator);
550            }
551    
552            /**
553            * Returns an ordered range of all the asset vocabularies where groupId = &#63;.
554            *
555            * <p>
556            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.
557            * </p>
558            *
559            * @param groupId the group ID
560            * @param start the lower bound of the range of asset vocabularies
561            * @param end the upper bound of the range of asset vocabularies (not inclusive)
562            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
563            * @param retrieveFromCache whether to retrieve from the finder cache
564            * @return the ordered range of matching asset vocabularies
565            */
566            public static List<AssetVocabulary> findByGroupId(long groupId, int start,
567                    int end, OrderByComparator<AssetVocabulary> orderByComparator,
568                    boolean retrieveFromCache) {
569                    return getPersistence()
570                                       .findByGroupId(groupId, start, end, orderByComparator,
571                            retrieveFromCache);
572            }
573    
574            /**
575            * Returns the first asset vocabulary in the ordered set where groupId = &#63;.
576            *
577            * @param groupId the group ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the first matching asset vocabulary
580            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
581            */
582            public static AssetVocabulary findByGroupId_First(long groupId,
583                    OrderByComparator<AssetVocabulary> orderByComparator)
584                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
585                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
586            }
587    
588            /**
589            * Returns the first asset vocabulary in the ordered set where groupId = &#63;.
590            *
591            * @param groupId the group ID
592            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
593            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
594            */
595            public static AssetVocabulary fetchByGroupId_First(long groupId,
596                    OrderByComparator<AssetVocabulary> orderByComparator) {
597                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
598            }
599    
600            /**
601            * Returns the last asset vocabulary in the ordered set where groupId = &#63;.
602            *
603            * @param groupId the group ID
604            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
605            * @return the last matching asset vocabulary
606            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
607            */
608            public static AssetVocabulary findByGroupId_Last(long groupId,
609                    OrderByComparator<AssetVocabulary> orderByComparator)
610                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
611                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
612            }
613    
614            /**
615            * Returns the last asset vocabulary in the ordered set where groupId = &#63;.
616            *
617            * @param groupId the group ID
618            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
619            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
620            */
621            public static AssetVocabulary fetchByGroupId_Last(long groupId,
622                    OrderByComparator<AssetVocabulary> orderByComparator) {
623                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
624            }
625    
626            /**
627            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = &#63;.
628            *
629            * @param vocabularyId the primary key of the current asset vocabulary
630            * @param groupId the group ID
631            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
632            * @return the previous, current, and next asset vocabulary
633            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
634            */
635            public static AssetVocabulary[] findByGroupId_PrevAndNext(
636                    long vocabularyId, long groupId,
637                    OrderByComparator<AssetVocabulary> orderByComparator)
638                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
639                    return getPersistence()
640                                       .findByGroupId_PrevAndNext(vocabularyId, groupId,
641                            orderByComparator);
642            }
643    
644            /**
645            * Returns all the asset vocabularies that the user has permission to view where groupId = &#63;.
646            *
647            * @param groupId the group ID
648            * @return the matching asset vocabularies that the user has permission to view
649            */
650            public static List<AssetVocabulary> filterFindByGroupId(long groupId) {
651                    return getPersistence().filterFindByGroupId(groupId);
652            }
653    
654            /**
655            * Returns a range of all the asset vocabularies that the user has permission to view where groupId = &#63;.
656            *
657            * <p>
658            * 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.
659            * </p>
660            *
661            * @param groupId the group ID
662            * @param start the lower bound of the range of asset vocabularies
663            * @param end the upper bound of the range of asset vocabularies (not inclusive)
664            * @return the range of matching asset vocabularies that the user has permission to view
665            */
666            public static List<AssetVocabulary> filterFindByGroupId(long groupId,
667                    int start, int end) {
668                    return getPersistence().filterFindByGroupId(groupId, start, end);
669            }
670    
671            /**
672            * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = &#63;.
673            *
674            * <p>
675            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.
676            * </p>
677            *
678            * @param groupId the group ID
679            * @param start the lower bound of the range of asset vocabularies
680            * @param end the upper bound of the range of asset vocabularies (not inclusive)
681            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
682            * @return the ordered range of matching asset vocabularies that the user has permission to view
683            */
684            public static List<AssetVocabulary> filterFindByGroupId(long groupId,
685                    int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) {
686                    return getPersistence()
687                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
688            }
689    
690            /**
691            * 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;.
692            *
693            * @param vocabularyId the primary key of the current asset vocabulary
694            * @param groupId the group ID
695            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
696            * @return the previous, current, and next asset vocabulary
697            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
698            */
699            public static AssetVocabulary[] filterFindByGroupId_PrevAndNext(
700                    long vocabularyId, long groupId,
701                    OrderByComparator<AssetVocabulary> orderByComparator)
702                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
703                    return getPersistence()
704                                       .filterFindByGroupId_PrevAndNext(vocabularyId, groupId,
705                            orderByComparator);
706            }
707    
708            /**
709            * Returns all the asset vocabularies that the user has permission to view where groupId = any &#63;.
710            *
711            * @param groupIds the group IDs
712            * @return the matching asset vocabularies that the user has permission to view
713            */
714            public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds) {
715                    return getPersistence().filterFindByGroupId(groupIds);
716            }
717    
718            /**
719            * Returns a range of all the asset vocabularies that the user has permission to view where groupId = any &#63;.
720            *
721            * <p>
722            * 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.
723            * </p>
724            *
725            * @param groupIds the group IDs
726            * @param start the lower bound of the range of asset vocabularies
727            * @param end the upper bound of the range of asset vocabularies (not inclusive)
728            * @return the range of matching asset vocabularies that the user has permission to view
729            */
730            public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds,
731                    int start, int end) {
732                    return getPersistence().filterFindByGroupId(groupIds, start, end);
733            }
734    
735            /**
736            * Returns an ordered range of all the asset vocabularies that the user has permission to view where groupId = any &#63;.
737            *
738            * <p>
739            * 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.
740            * </p>
741            *
742            * @param groupIds the group IDs
743            * @param start the lower bound of the range of asset vocabularies
744            * @param end the upper bound of the range of asset vocabularies (not inclusive)
745            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
746            * @return the ordered range of matching asset vocabularies that the user has permission to view
747            */
748            public static List<AssetVocabulary> filterFindByGroupId(long[] groupIds,
749                    int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) {
750                    return getPersistence()
751                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
752            }
753    
754            /**
755            * Returns all the asset vocabularies where groupId = any &#63;.
756            *
757            * <p>
758            * 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.
759            * </p>
760            *
761            * @param groupIds the group IDs
762            * @return the matching asset vocabularies
763            */
764            public static List<AssetVocabulary> findByGroupId(long[] groupIds) {
765                    return getPersistence().findByGroupId(groupIds);
766            }
767    
768            /**
769            * Returns a range of all the asset vocabularies where groupId = any &#63;.
770            *
771            * <p>
772            * 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.
773            * </p>
774            *
775            * @param groupIds the group IDs
776            * @param start the lower bound of the range of asset vocabularies
777            * @param end the upper bound of the range of asset vocabularies (not inclusive)
778            * @return the range of matching asset vocabularies
779            */
780            public static List<AssetVocabulary> findByGroupId(long[] groupIds,
781                    int start, int end) {
782                    return getPersistence().findByGroupId(groupIds, start, end);
783            }
784    
785            /**
786            * Returns an ordered range of all the asset vocabularies where groupId = any &#63;.
787            *
788            * <p>
789            * 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.
790            * </p>
791            *
792            * @param groupIds the group IDs
793            * @param start the lower bound of the range of asset vocabularies
794            * @param end the upper bound of the range of asset vocabularies (not inclusive)
795            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
796            * @return the ordered range of matching asset vocabularies
797            */
798            public static List<AssetVocabulary> findByGroupId(long[] groupIds,
799                    int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) {
800                    return getPersistence()
801                                       .findByGroupId(groupIds, start, end, orderByComparator);
802            }
803    
804            /**
805            * Returns an ordered range of all the asset vocabularies where groupId = &#63;, optionally using the finder cache.
806            *
807            * <p>
808            * 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.
809            * </p>
810            *
811            * @param groupId the group ID
812            * @param start the lower bound of the range of asset vocabularies
813            * @param end the upper bound of the range of asset vocabularies (not inclusive)
814            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
815            * @param retrieveFromCache whether to retrieve from the finder cache
816            * @return the ordered range of matching asset vocabularies
817            */
818            public static List<AssetVocabulary> findByGroupId(long[] groupIds,
819                    int start, int end,
820                    OrderByComparator<AssetVocabulary> orderByComparator,
821                    boolean retrieveFromCache) {
822                    return getPersistence()
823                                       .findByGroupId(groupIds, start, end, orderByComparator,
824                            retrieveFromCache);
825            }
826    
827            /**
828            * Removes all the asset vocabularies where groupId = &#63; from the database.
829            *
830            * @param groupId the group ID
831            */
832            public static void removeByGroupId(long groupId) {
833                    getPersistence().removeByGroupId(groupId);
834            }
835    
836            /**
837            * Returns the number of asset vocabularies where groupId = &#63;.
838            *
839            * @param groupId the group ID
840            * @return the number of matching asset vocabularies
841            */
842            public static int countByGroupId(long groupId) {
843                    return getPersistence().countByGroupId(groupId);
844            }
845    
846            /**
847            * Returns the number of asset vocabularies where groupId = any &#63;.
848            *
849            * @param groupIds the group IDs
850            * @return the number of matching asset vocabularies
851            */
852            public static int countByGroupId(long[] groupIds) {
853                    return getPersistence().countByGroupId(groupIds);
854            }
855    
856            /**
857            * Returns the number of asset vocabularies that the user has permission to view where groupId = &#63;.
858            *
859            * @param groupId the group ID
860            * @return the number of matching asset vocabularies that the user has permission to view
861            */
862            public static int filterCountByGroupId(long groupId) {
863                    return getPersistence().filterCountByGroupId(groupId);
864            }
865    
866            /**
867            * Returns the number of asset vocabularies that the user has permission to view where groupId = any &#63;.
868            *
869            * @param groupIds the group IDs
870            * @return the number of matching asset vocabularies that the user has permission to view
871            */
872            public static int filterCountByGroupId(long[] groupIds) {
873                    return getPersistence().filterCountByGroupId(groupIds);
874            }
875    
876            /**
877            * Returns all the asset vocabularies where companyId = &#63;.
878            *
879            * @param companyId the company ID
880            * @return the matching asset vocabularies
881            */
882            public static List<AssetVocabulary> findByCompanyId(long companyId) {
883                    return getPersistence().findByCompanyId(companyId);
884            }
885    
886            /**
887            * Returns a range of all the asset vocabularies where companyId = &#63;.
888            *
889            * <p>
890            * 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.
891            * </p>
892            *
893            * @param companyId the company ID
894            * @param start the lower bound of the range of asset vocabularies
895            * @param end the upper bound of the range of asset vocabularies (not inclusive)
896            * @return the range of matching asset vocabularies
897            */
898            public static List<AssetVocabulary> findByCompanyId(long companyId,
899                    int start, int end) {
900                    return getPersistence().findByCompanyId(companyId, start, end);
901            }
902    
903            /**
904            * Returns an ordered range of all the asset vocabularies where companyId = &#63;.
905            *
906            * <p>
907            * 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.
908            * </p>
909            *
910            * @param companyId the company ID
911            * @param start the lower bound of the range of asset vocabularies
912            * @param end the upper bound of the range of asset vocabularies (not inclusive)
913            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
914            * @return the ordered range of matching asset vocabularies
915            */
916            public static List<AssetVocabulary> findByCompanyId(long companyId,
917                    int start, int end, OrderByComparator<AssetVocabulary> orderByComparator) {
918                    return getPersistence()
919                                       .findByCompanyId(companyId, start, end, orderByComparator);
920            }
921    
922            /**
923            * Returns an ordered range of all the asset vocabularies where companyId = &#63;.
924            *
925            * <p>
926            * 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.
927            * </p>
928            *
929            * @param companyId the company ID
930            * @param start the lower bound of the range of asset vocabularies
931            * @param end the upper bound of the range of asset vocabularies (not inclusive)
932            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
933            * @param retrieveFromCache whether to retrieve from the finder cache
934            * @return the ordered range of matching asset vocabularies
935            */
936            public static List<AssetVocabulary> findByCompanyId(long companyId,
937                    int start, int end,
938                    OrderByComparator<AssetVocabulary> orderByComparator,
939                    boolean retrieveFromCache) {
940                    return getPersistence()
941                                       .findByCompanyId(companyId, start, end, orderByComparator,
942                            retrieveFromCache);
943            }
944    
945            /**
946            * Returns the first asset vocabulary in the ordered set where companyId = &#63;.
947            *
948            * @param companyId the company ID
949            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
950            * @return the first matching asset vocabulary
951            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
952            */
953            public static AssetVocabulary findByCompanyId_First(long companyId,
954                    OrderByComparator<AssetVocabulary> orderByComparator)
955                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
956                    return getPersistence()
957                                       .findByCompanyId_First(companyId, orderByComparator);
958            }
959    
960            /**
961            * Returns the first asset vocabulary in the ordered set where companyId = &#63;.
962            *
963            * @param companyId the company ID
964            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
965            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
966            */
967            public static AssetVocabulary fetchByCompanyId_First(long companyId,
968                    OrderByComparator<AssetVocabulary> orderByComparator) {
969                    return getPersistence()
970                                       .fetchByCompanyId_First(companyId, orderByComparator);
971            }
972    
973            /**
974            * Returns the last asset vocabulary in the ordered set where companyId = &#63;.
975            *
976            * @param companyId the company ID
977            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
978            * @return the last matching asset vocabulary
979            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
980            */
981            public static AssetVocabulary findByCompanyId_Last(long companyId,
982                    OrderByComparator<AssetVocabulary> orderByComparator)
983                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
984                    return getPersistence()
985                                       .findByCompanyId_Last(companyId, orderByComparator);
986            }
987    
988            /**
989            * Returns the last asset vocabulary in the ordered set where companyId = &#63;.
990            *
991            * @param companyId the company ID
992            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
993            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
994            */
995            public static AssetVocabulary fetchByCompanyId_Last(long companyId,
996                    OrderByComparator<AssetVocabulary> orderByComparator) {
997                    return getPersistence()
998                                       .fetchByCompanyId_Last(companyId, orderByComparator);
999            }
1000    
1001            /**
1002            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where companyId = &#63;.
1003            *
1004            * @param vocabularyId the primary key of the current asset vocabulary
1005            * @param companyId the company ID
1006            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1007            * @return the previous, current, and next asset vocabulary
1008            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1009            */
1010            public static AssetVocabulary[] findByCompanyId_PrevAndNext(
1011                    long vocabularyId, long companyId,
1012                    OrderByComparator<AssetVocabulary> orderByComparator)
1013                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
1014                    return getPersistence()
1015                                       .findByCompanyId_PrevAndNext(vocabularyId, companyId,
1016                            orderByComparator);
1017            }
1018    
1019            /**
1020            * Removes all the asset vocabularies where companyId = &#63; from the database.
1021            *
1022            * @param companyId the company ID
1023            */
1024            public static void removeByCompanyId(long companyId) {
1025                    getPersistence().removeByCompanyId(companyId);
1026            }
1027    
1028            /**
1029            * Returns the number of asset vocabularies where companyId = &#63;.
1030            *
1031            * @param companyId the company ID
1032            * @return the number of matching asset vocabularies
1033            */
1034            public static int countByCompanyId(long companyId) {
1035                    return getPersistence().countByCompanyId(companyId);
1036            }
1037    
1038            /**
1039            * Returns the asset vocabulary where groupId = &#63; and name = &#63; or throws a {@link NoSuchVocabularyException} if it could not be found.
1040            *
1041            * @param groupId the group ID
1042            * @param name the name
1043            * @return the matching asset vocabulary
1044            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
1045            */
1046            public static AssetVocabulary findByG_N(long groupId, java.lang.String name)
1047                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
1048                    return getPersistence().findByG_N(groupId, name);
1049            }
1050    
1051            /**
1052            * 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.
1053            *
1054            * @param groupId the group ID
1055            * @param name the name
1056            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
1057            */
1058            public static AssetVocabulary fetchByG_N(long groupId, java.lang.String name) {
1059                    return getPersistence().fetchByG_N(groupId, name);
1060            }
1061    
1062            /**
1063            * 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.
1064            *
1065            * @param groupId the group ID
1066            * @param name the name
1067            * @param retrieveFromCache whether to retrieve from the finder cache
1068            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
1069            */
1070            public static AssetVocabulary fetchByG_N(long groupId,
1071                    java.lang.String name, boolean retrieveFromCache) {
1072                    return getPersistence().fetchByG_N(groupId, name, retrieveFromCache);
1073            }
1074    
1075            /**
1076            * Removes the asset vocabulary where groupId = &#63; and name = &#63; from the database.
1077            *
1078            * @param groupId the group ID
1079            * @param name the name
1080            * @return the asset vocabulary that was removed
1081            */
1082            public static AssetVocabulary removeByG_N(long groupId,
1083                    java.lang.String name)
1084                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
1085                    return getPersistence().removeByG_N(groupId, name);
1086            }
1087    
1088            /**
1089            * Returns the number of asset vocabularies where groupId = &#63; and name = &#63;.
1090            *
1091            * @param groupId the group ID
1092            * @param name the name
1093            * @return the number of matching asset vocabularies
1094            */
1095            public static int countByG_N(long groupId, java.lang.String name) {
1096                    return getPersistence().countByG_N(groupId, name);
1097            }
1098    
1099            /**
1100            * Returns all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
1101            *
1102            * @param groupId the group ID
1103            * @param name the name
1104            * @return the matching asset vocabularies
1105            */
1106            public static List<AssetVocabulary> findByG_LikeN(long groupId,
1107                    java.lang.String name) {
1108                    return getPersistence().findByG_LikeN(groupId, name);
1109            }
1110    
1111            /**
1112            * Returns a range of all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
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 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.
1116            * </p>
1117            *
1118            * @param groupId the group ID
1119            * @param name the name
1120            * @param start the lower bound of the range of asset vocabularies
1121            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1122            * @return the range of matching asset vocabularies
1123            */
1124            public static List<AssetVocabulary> findByG_LikeN(long groupId,
1125                    java.lang.String name, int start, int end) {
1126                    return getPersistence().findByG_LikeN(groupId, name, start, end);
1127            }
1128    
1129            /**
1130            * Returns an ordered range of all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
1131            *
1132            * <p>
1133            * 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.
1134            * </p>
1135            *
1136            * @param groupId the group ID
1137            * @param name the name
1138            * @param start the lower bound of the range of asset vocabularies
1139            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1140            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1141            * @return the ordered range of matching asset vocabularies
1142            */
1143            public static List<AssetVocabulary> findByG_LikeN(long groupId,
1144                    java.lang.String name, int start, int end,
1145                    OrderByComparator<AssetVocabulary> orderByComparator) {
1146                    return getPersistence()
1147                                       .findByG_LikeN(groupId, name, start, end, orderByComparator);
1148            }
1149    
1150            /**
1151            * Returns an ordered range of all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
1152            *
1153            * <p>
1154            * 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.
1155            * </p>
1156            *
1157            * @param groupId the group ID
1158            * @param name the name
1159            * @param start the lower bound of the range of asset vocabularies
1160            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1161            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1162            * @param retrieveFromCache whether to retrieve from the finder cache
1163            * @return the ordered range of matching asset vocabularies
1164            */
1165            public static List<AssetVocabulary> findByG_LikeN(long groupId,
1166                    java.lang.String name, int start, int end,
1167                    OrderByComparator<AssetVocabulary> orderByComparator,
1168                    boolean retrieveFromCache) {
1169                    return getPersistence()
1170                                       .findByG_LikeN(groupId, name, start, end, orderByComparator,
1171                            retrieveFromCache);
1172            }
1173    
1174            /**
1175            * Returns the first asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
1176            *
1177            * @param groupId the group ID
1178            * @param name the name
1179            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1180            * @return the first matching asset vocabulary
1181            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
1182            */
1183            public static AssetVocabulary findByG_LikeN_First(long groupId,
1184                    java.lang.String name,
1185                    OrderByComparator<AssetVocabulary> orderByComparator)
1186                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
1187                    return getPersistence()
1188                                       .findByG_LikeN_First(groupId, name, orderByComparator);
1189            }
1190    
1191            /**
1192            * Returns the first asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
1193            *
1194            * @param groupId the group ID
1195            * @param name the name
1196            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1197            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
1198            */
1199            public static AssetVocabulary fetchByG_LikeN_First(long groupId,
1200                    java.lang.String name,
1201                    OrderByComparator<AssetVocabulary> orderByComparator) {
1202                    return getPersistence()
1203                                       .fetchByG_LikeN_First(groupId, name, orderByComparator);
1204            }
1205    
1206            /**
1207            * Returns the last asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
1208            *
1209            * @param groupId the group ID
1210            * @param name the name
1211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1212            * @return the last matching asset vocabulary
1213            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
1214            */
1215            public static AssetVocabulary findByG_LikeN_Last(long groupId,
1216                    java.lang.String name,
1217                    OrderByComparator<AssetVocabulary> orderByComparator)
1218                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
1219                    return getPersistence()
1220                                       .findByG_LikeN_Last(groupId, name, orderByComparator);
1221            }
1222    
1223            /**
1224            * Returns the last asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
1225            *
1226            * @param groupId the group ID
1227            * @param name the name
1228            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1229            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
1230            */
1231            public static AssetVocabulary fetchByG_LikeN_Last(long groupId,
1232                    java.lang.String name,
1233                    OrderByComparator<AssetVocabulary> orderByComparator) {
1234                    return getPersistence()
1235                                       .fetchByG_LikeN_Last(groupId, name, orderByComparator);
1236            }
1237    
1238            /**
1239            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
1240            *
1241            * @param vocabularyId the primary key of the current asset vocabulary
1242            * @param groupId the group ID
1243            * @param name the name
1244            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1245            * @return the previous, current, and next asset vocabulary
1246            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1247            */
1248            public static AssetVocabulary[] findByG_LikeN_PrevAndNext(
1249                    long vocabularyId, long groupId, java.lang.String name,
1250                    OrderByComparator<AssetVocabulary> orderByComparator)
1251                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
1252                    return getPersistence()
1253                                       .findByG_LikeN_PrevAndNext(vocabularyId, groupId, name,
1254                            orderByComparator);
1255            }
1256    
1257            /**
1258            * Returns all the asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1259            *
1260            * @param groupId the group ID
1261            * @param name the name
1262            * @return the matching asset vocabularies that the user has permission to view
1263            */
1264            public static List<AssetVocabulary> filterFindByG_LikeN(long groupId,
1265                    java.lang.String name) {
1266                    return getPersistence().filterFindByG_LikeN(groupId, name);
1267            }
1268    
1269            /**
1270            * Returns a range of all the asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1271            *
1272            * <p>
1273            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.
1274            * </p>
1275            *
1276            * @param groupId the group ID
1277            * @param name the name
1278            * @param start the lower bound of the range of asset vocabularies
1279            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1280            * @return the range of matching asset vocabularies that the user has permission to view
1281            */
1282            public static List<AssetVocabulary> filterFindByG_LikeN(long groupId,
1283                    java.lang.String name, int start, int end) {
1284                    return getPersistence().filterFindByG_LikeN(groupId, name, start, end);
1285            }
1286    
1287            /**
1288            * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = &#63; and name LIKE &#63;.
1289            *
1290            * <p>
1291            * 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.
1292            * </p>
1293            *
1294            * @param groupId the group ID
1295            * @param name the name
1296            * @param start the lower bound of the range of asset vocabularies
1297            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1298            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1299            * @return the ordered range of matching asset vocabularies that the user has permission to view
1300            */
1301            public static List<AssetVocabulary> filterFindByG_LikeN(long groupId,
1302                    java.lang.String name, int start, int end,
1303                    OrderByComparator<AssetVocabulary> orderByComparator) {
1304                    return getPersistence()
1305                                       .filterFindByG_LikeN(groupId, name, start, end,
1306                            orderByComparator);
1307            }
1308    
1309            /**
1310            * 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;.
1311            *
1312            * @param vocabularyId the primary key of the current asset vocabulary
1313            * @param groupId the group ID
1314            * @param name the name
1315            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1316            * @return the previous, current, and next asset vocabulary
1317            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1318            */
1319            public static AssetVocabulary[] filterFindByG_LikeN_PrevAndNext(
1320                    long vocabularyId, long groupId, java.lang.String name,
1321                    OrderByComparator<AssetVocabulary> orderByComparator)
1322                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
1323                    return getPersistence()
1324                                       .filterFindByG_LikeN_PrevAndNext(vocabularyId, groupId,
1325                            name, orderByComparator);
1326            }
1327    
1328            /**
1329            * Removes all the asset vocabularies where groupId = &#63; and name LIKE &#63; from the database.
1330            *
1331            * @param groupId the group ID
1332            * @param name the name
1333            */
1334            public static void removeByG_LikeN(long groupId, java.lang.String name) {
1335                    getPersistence().removeByG_LikeN(groupId, name);
1336            }
1337    
1338            /**
1339            * Returns the number of asset vocabularies where groupId = &#63; and name LIKE &#63;.
1340            *
1341            * @param groupId the group ID
1342            * @param name the name
1343            * @return the number of matching asset vocabularies
1344            */
1345            public static int countByG_LikeN(long groupId, java.lang.String name) {
1346                    return getPersistence().countByG_LikeN(groupId, name);
1347            }
1348    
1349            /**
1350            * Returns the number of asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1351            *
1352            * @param groupId the group ID
1353            * @param name the name
1354            * @return the number of matching asset vocabularies that the user has permission to view
1355            */
1356            public static int filterCountByG_LikeN(long groupId, java.lang.String name) {
1357                    return getPersistence().filterCountByG_LikeN(groupId, name);
1358            }
1359    
1360            /**
1361            * Caches the asset vocabulary in the entity cache if it is enabled.
1362            *
1363            * @param assetVocabulary the asset vocabulary
1364            */
1365            public static void cacheResult(AssetVocabulary assetVocabulary) {
1366                    getPersistence().cacheResult(assetVocabulary);
1367            }
1368    
1369            /**
1370            * Caches the asset vocabularies in the entity cache if it is enabled.
1371            *
1372            * @param assetVocabularies the asset vocabularies
1373            */
1374            public static void cacheResult(List<AssetVocabulary> assetVocabularies) {
1375                    getPersistence().cacheResult(assetVocabularies);
1376            }
1377    
1378            /**
1379            * Creates a new asset vocabulary with the primary key. Does not add the asset vocabulary to the database.
1380            *
1381            * @param vocabularyId the primary key for the new asset vocabulary
1382            * @return the new asset vocabulary
1383            */
1384            public static AssetVocabulary create(long vocabularyId) {
1385                    return getPersistence().create(vocabularyId);
1386            }
1387    
1388            /**
1389            * Removes the asset vocabulary with the primary key from the database. Also notifies the appropriate model listeners.
1390            *
1391            * @param vocabularyId the primary key of the asset vocabulary
1392            * @return the asset vocabulary that was removed
1393            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1394            */
1395            public static AssetVocabulary remove(long vocabularyId)
1396                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
1397                    return getPersistence().remove(vocabularyId);
1398            }
1399    
1400            public static AssetVocabulary updateImpl(AssetVocabulary assetVocabulary) {
1401                    return getPersistence().updateImpl(assetVocabulary);
1402            }
1403    
1404            /**
1405            * Returns the asset vocabulary with the primary key or throws a {@link NoSuchVocabularyException} if it could not be found.
1406            *
1407            * @param vocabularyId the primary key of the asset vocabulary
1408            * @return the asset vocabulary
1409            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1410            */
1411            public static AssetVocabulary findByPrimaryKey(long vocabularyId)
1412                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException {
1413                    return getPersistence().findByPrimaryKey(vocabularyId);
1414            }
1415    
1416            /**
1417            * Returns the asset vocabulary with the primary key or returns <code>null</code> if it could not be found.
1418            *
1419            * @param vocabularyId the primary key of the asset vocabulary
1420            * @return the asset vocabulary, or <code>null</code> if a asset vocabulary with the primary key could not be found
1421            */
1422            public static AssetVocabulary fetchByPrimaryKey(long vocabularyId) {
1423                    return getPersistence().fetchByPrimaryKey(vocabularyId);
1424            }
1425    
1426            public static java.util.Map<java.io.Serializable, AssetVocabulary> fetchByPrimaryKeys(
1427                    java.util.Set<java.io.Serializable> primaryKeys) {
1428                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1429            }
1430    
1431            /**
1432            * Returns all the asset vocabularies.
1433            *
1434            * @return the asset vocabularies
1435            */
1436            public static List<AssetVocabulary> findAll() {
1437                    return getPersistence().findAll();
1438            }
1439    
1440            /**
1441            * Returns a range of all the asset vocabularies.
1442            *
1443            * <p>
1444            * 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.
1445            * </p>
1446            *
1447            * @param start the lower bound of the range of asset vocabularies
1448            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1449            * @return the range of asset vocabularies
1450            */
1451            public static List<AssetVocabulary> findAll(int start, int end) {
1452                    return getPersistence().findAll(start, end);
1453            }
1454    
1455            /**
1456            * Returns an ordered range of all the asset vocabularies.
1457            *
1458            * <p>
1459            * 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.
1460            * </p>
1461            *
1462            * @param start the lower bound of the range of asset vocabularies
1463            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1464            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1465            * @return the ordered range of asset vocabularies
1466            */
1467            public static List<AssetVocabulary> findAll(int start, int end,
1468                    OrderByComparator<AssetVocabulary> orderByComparator) {
1469                    return getPersistence().findAll(start, end, orderByComparator);
1470            }
1471    
1472            /**
1473            * Returns an ordered range of all the asset vocabularies.
1474            *
1475            * <p>
1476            * 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.
1477            * </p>
1478            *
1479            * @param start the lower bound of the range of asset vocabularies
1480            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1481            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1482            * @param retrieveFromCache whether to retrieve from the finder cache
1483            * @return the ordered range of asset vocabularies
1484            */
1485            public static List<AssetVocabulary> findAll(int start, int end,
1486                    OrderByComparator<AssetVocabulary> orderByComparator,
1487                    boolean retrieveFromCache) {
1488                    return getPersistence()
1489                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1490            }
1491    
1492            /**
1493            * Removes all the asset vocabularies from the database.
1494            */
1495            public static void removeAll() {
1496                    getPersistence().removeAll();
1497            }
1498    
1499            /**
1500            * Returns the number of asset vocabularies.
1501            *
1502            * @return the number of asset vocabularies
1503            */
1504            public static int countAll() {
1505                    return getPersistence().countAll();
1506            }
1507    
1508            public static java.util.Set<java.lang.String> getBadColumnNames() {
1509                    return getPersistence().getBadColumnNames();
1510            }
1511    
1512            public static AssetVocabularyPersistence getPersistence() {
1513                    if (_persistence == null) {
1514                            _persistence = (AssetVocabularyPersistence)PortalBeanLocatorUtil.locate(AssetVocabularyPersistence.class.getName());
1515    
1516                            ReferenceRegistry.registerReference(AssetVocabularyUtil.class,
1517                                    "_persistence");
1518                    }
1519    
1520                    return _persistence;
1521            }
1522    
1523            private static AssetVocabularyPersistence _persistence;
1524    }