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