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