001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.asset.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.asset.model.AssetTag;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the asset tag service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetTagPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see AssetTagPersistence
038     * @see com.liferay.portlet.asset.service.persistence.impl.AssetTagPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class AssetTagUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(AssetTag assetTag) {
060                    getPersistence().clearCache(assetTag);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<AssetTag> findWithDynamicQuery(DynamicQuery dynamicQuery) {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<AssetTag> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end) {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<AssetTag> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<AssetTag> orderByComparator) {
091                    return getPersistence()
092                                       .findWithDynamicQuery(dynamicQuery, start, end,
093                            orderByComparator);
094            }
095    
096            /**
097             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
098             */
099            public static AssetTag update(AssetTag assetTag) {
100                    return getPersistence().update(assetTag);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
105             */
106            public static AssetTag update(AssetTag assetTag,
107                    ServiceContext serviceContext) {
108                    return getPersistence().update(assetTag, serviceContext);
109            }
110    
111            /**
112            * Returns all the asset tags where groupId = &#63;.
113            *
114            * @param groupId the group ID
115            * @return the matching asset tags
116            */
117            public static List<AssetTag> findByGroupId(long groupId) {
118                    return getPersistence().findByGroupId(groupId);
119            }
120    
121            /**
122            * Returns a range of all the asset tags where groupId = &#63;.
123            *
124            * <p>
125            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
126            * </p>
127            *
128            * @param groupId the group ID
129            * @param start the lower bound of the range of asset tags
130            * @param end the upper bound of the range of asset tags (not inclusive)
131            * @return the range of matching asset tags
132            */
133            public static List<AssetTag> findByGroupId(long groupId, int start, int end) {
134                    return getPersistence().findByGroupId(groupId, start, end);
135            }
136    
137            /**
138            * Returns an ordered range of all the asset tags where groupId = &#63;.
139            *
140            * <p>
141            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
142            * </p>
143            *
144            * @param groupId the group ID
145            * @param start the lower bound of the range of asset tags
146            * @param end the upper bound of the range of asset tags (not inclusive)
147            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
148            * @return the ordered range of matching asset tags
149            */
150            public static List<AssetTag> findByGroupId(long groupId, int start,
151                    int end, OrderByComparator<AssetTag> orderByComparator) {
152                    return getPersistence()
153                                       .findByGroupId(groupId, start, end, orderByComparator);
154            }
155    
156            /**
157            * Returns the first asset tag in the ordered set where groupId = &#63;.
158            *
159            * @param groupId the group ID
160            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
161            * @return the first matching asset tag
162            * @throws NoSuchTagException if a matching asset tag could not be found
163            */
164            public static AssetTag findByGroupId_First(long groupId,
165                    OrderByComparator<AssetTag> orderByComparator)
166                    throws com.liferay.portlet.asset.NoSuchTagException {
167                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
168            }
169    
170            /**
171            * Returns the first asset tag in the ordered set where groupId = &#63;.
172            *
173            * @param groupId the group ID
174            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
175            * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found
176            */
177            public static AssetTag fetchByGroupId_First(long groupId,
178                    OrderByComparator<AssetTag> orderByComparator) {
179                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
180            }
181    
182            /**
183            * Returns the last asset tag in the ordered set where groupId = &#63;.
184            *
185            * @param groupId the group ID
186            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
187            * @return the last matching asset tag
188            * @throws NoSuchTagException if a matching asset tag could not be found
189            */
190            public static AssetTag findByGroupId_Last(long groupId,
191                    OrderByComparator<AssetTag> orderByComparator)
192                    throws com.liferay.portlet.asset.NoSuchTagException {
193                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
194            }
195    
196            /**
197            * Returns the last asset tag in the ordered set where groupId = &#63;.
198            *
199            * @param groupId the group ID
200            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
201            * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found
202            */
203            public static AssetTag fetchByGroupId_Last(long groupId,
204                    OrderByComparator<AssetTag> orderByComparator) {
205                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
206            }
207    
208            /**
209            * Returns the asset tags before and after the current asset tag in the ordered set where groupId = &#63;.
210            *
211            * @param tagId the primary key of the current asset tag
212            * @param groupId the group ID
213            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
214            * @return the previous, current, and next asset tag
215            * @throws NoSuchTagException if a asset tag with the primary key could not be found
216            */
217            public static AssetTag[] findByGroupId_PrevAndNext(long tagId,
218                    long groupId, OrderByComparator<AssetTag> orderByComparator)
219                    throws com.liferay.portlet.asset.NoSuchTagException {
220                    return getPersistence()
221                                       .findByGroupId_PrevAndNext(tagId, groupId, orderByComparator);
222            }
223    
224            /**
225            * Returns all the asset tags that the user has permission to view where groupId = &#63;.
226            *
227            * @param groupId the group ID
228            * @return the matching asset tags that the user has permission to view
229            */
230            public static List<AssetTag> filterFindByGroupId(long groupId) {
231                    return getPersistence().filterFindByGroupId(groupId);
232            }
233    
234            /**
235            * Returns a range of all the asset tags that the user has permission to view where groupId = &#63;.
236            *
237            * <p>
238            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
239            * </p>
240            *
241            * @param groupId the group ID
242            * @param start the lower bound of the range of asset tags
243            * @param end the upper bound of the range of asset tags (not inclusive)
244            * @return the range of matching asset tags that the user has permission to view
245            */
246            public static List<AssetTag> filterFindByGroupId(long groupId, int start,
247                    int end) {
248                    return getPersistence().filterFindByGroupId(groupId, start, end);
249            }
250    
251            /**
252            * Returns an ordered range of all the asset tags that the user has permissions to view where groupId = &#63;.
253            *
254            * <p>
255            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
256            * </p>
257            *
258            * @param groupId the group ID
259            * @param start the lower bound of the range of asset tags
260            * @param end the upper bound of the range of asset tags (not inclusive)
261            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
262            * @return the ordered range of matching asset tags that the user has permission to view
263            */
264            public static List<AssetTag> filterFindByGroupId(long groupId, int start,
265                    int end, OrderByComparator<AssetTag> orderByComparator) {
266                    return getPersistence()
267                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
268            }
269    
270            /**
271            * Returns the asset tags before and after the current asset tag in the ordered set of asset tags that the user has permission to view where groupId = &#63;.
272            *
273            * @param tagId the primary key of the current asset tag
274            * @param groupId the group ID
275            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
276            * @return the previous, current, and next asset tag
277            * @throws NoSuchTagException if a asset tag with the primary key could not be found
278            */
279            public static AssetTag[] filterFindByGroupId_PrevAndNext(long tagId,
280                    long groupId, OrderByComparator<AssetTag> orderByComparator)
281                    throws com.liferay.portlet.asset.NoSuchTagException {
282                    return getPersistence()
283                                       .filterFindByGroupId_PrevAndNext(tagId, groupId,
284                            orderByComparator);
285            }
286    
287            /**
288            * Returns all the asset tags that the user has permission to view where groupId = any &#63;.
289            *
290            * @param groupIds the group IDs
291            * @return the matching asset tags that the user has permission to view
292            */
293            public static List<AssetTag> filterFindByGroupId(long[] groupIds) {
294                    return getPersistence().filterFindByGroupId(groupIds);
295            }
296    
297            /**
298            * Returns a range of all the asset tags that the user has permission to view where groupId = any &#63;.
299            *
300            * <p>
301            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
302            * </p>
303            *
304            * @param groupIds the group IDs
305            * @param start the lower bound of the range of asset tags
306            * @param end the upper bound of the range of asset tags (not inclusive)
307            * @return the range of matching asset tags that the user has permission to view
308            */
309            public static List<AssetTag> filterFindByGroupId(long[] groupIds,
310                    int start, int end) {
311                    return getPersistence().filterFindByGroupId(groupIds, start, end);
312            }
313    
314            /**
315            * Returns an ordered range of all the asset tags that the user has permission to view where groupId = any &#63;.
316            *
317            * <p>
318            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
319            * </p>
320            *
321            * @param groupIds the group IDs
322            * @param start the lower bound of the range of asset tags
323            * @param end the upper bound of the range of asset tags (not inclusive)
324            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
325            * @return the ordered range of matching asset tags that the user has permission to view
326            */
327            public static List<AssetTag> filterFindByGroupId(long[] groupIds,
328                    int start, int end, OrderByComparator<AssetTag> orderByComparator) {
329                    return getPersistence()
330                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
331            }
332    
333            /**
334            * Returns all the asset tags where groupId = any &#63;.
335            *
336            * <p>
337            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
338            * </p>
339            *
340            * @param groupIds the group IDs
341            * @return the matching asset tags
342            */
343            public static List<AssetTag> findByGroupId(long[] groupIds) {
344                    return getPersistence().findByGroupId(groupIds);
345            }
346    
347            /**
348            * Returns a range of all the asset tags where groupId = any &#63;.
349            *
350            * <p>
351            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
352            * </p>
353            *
354            * @param groupIds the group IDs
355            * @param start the lower bound of the range of asset tags
356            * @param end the upper bound of the range of asset tags (not inclusive)
357            * @return the range of matching asset tags
358            */
359            public static List<AssetTag> findByGroupId(long[] groupIds, int start,
360                    int end) {
361                    return getPersistence().findByGroupId(groupIds, start, end);
362            }
363    
364            /**
365            * Returns an ordered range of all the asset tags where groupId = any &#63;.
366            *
367            * <p>
368            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
369            * </p>
370            *
371            * @param groupIds the group IDs
372            * @param start the lower bound of the range of asset tags
373            * @param end the upper bound of the range of asset tags (not inclusive)
374            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
375            * @return the ordered range of matching asset tags
376            */
377            public static List<AssetTag> findByGroupId(long[] groupIds, int start,
378                    int end, OrderByComparator<AssetTag> orderByComparator) {
379                    return getPersistence()
380                                       .findByGroupId(groupIds, start, end, orderByComparator);
381            }
382    
383            /**
384            * Removes all the asset tags where groupId = &#63; from the database.
385            *
386            * @param groupId the group ID
387            */
388            public static void removeByGroupId(long groupId) {
389                    getPersistence().removeByGroupId(groupId);
390            }
391    
392            /**
393            * Returns the number of asset tags where groupId = &#63;.
394            *
395            * @param groupId the group ID
396            * @return the number of matching asset tags
397            */
398            public static int countByGroupId(long groupId) {
399                    return getPersistence().countByGroupId(groupId);
400            }
401    
402            /**
403            * Returns the number of asset tags where groupId = any &#63;.
404            *
405            * @param groupIds the group IDs
406            * @return the number of matching asset tags
407            */
408            public static int countByGroupId(long[] groupIds) {
409                    return getPersistence().countByGroupId(groupIds);
410            }
411    
412            /**
413            * Returns the number of asset tags that the user has permission to view where groupId = &#63;.
414            *
415            * @param groupId the group ID
416            * @return the number of matching asset tags that the user has permission to view
417            */
418            public static int filterCountByGroupId(long groupId) {
419                    return getPersistence().filterCountByGroupId(groupId);
420            }
421    
422            /**
423            * Returns the number of asset tags that the user has permission to view where groupId = any &#63;.
424            *
425            * @param groupIds the group IDs
426            * @return the number of matching asset tags that the user has permission to view
427            */
428            public static int filterCountByGroupId(long[] groupIds) {
429                    return getPersistence().filterCountByGroupId(groupIds);
430            }
431    
432            /**
433            * Returns the asset tag where groupId = &#63; and name = &#63; or throws a {@link NoSuchTagException} if it could not be found.
434            *
435            * @param groupId the group ID
436            * @param name the name
437            * @return the matching asset tag
438            * @throws NoSuchTagException if a matching asset tag could not be found
439            */
440            public static AssetTag findByG_N(long groupId, java.lang.String name)
441                    throws com.liferay.portlet.asset.NoSuchTagException {
442                    return getPersistence().findByG_N(groupId, name);
443            }
444    
445            /**
446            * Returns the asset tag where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
447            *
448            * @param groupId the group ID
449            * @param name the name
450            * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found
451            */
452            public static AssetTag fetchByG_N(long groupId, java.lang.String name) {
453                    return getPersistence().fetchByG_N(groupId, name);
454            }
455    
456            /**
457            * Returns the asset tag where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
458            *
459            * @param groupId the group ID
460            * @param name the name
461            * @param retrieveFromCache whether to use the finder cache
462            * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found
463            */
464            public static AssetTag fetchByG_N(long groupId, java.lang.String name,
465                    boolean retrieveFromCache) {
466                    return getPersistence().fetchByG_N(groupId, name, retrieveFromCache);
467            }
468    
469            /**
470            * Removes the asset tag where groupId = &#63; and name = &#63; from the database.
471            *
472            * @param groupId the group ID
473            * @param name the name
474            * @return the asset tag that was removed
475            */
476            public static AssetTag removeByG_N(long groupId, java.lang.String name)
477                    throws com.liferay.portlet.asset.NoSuchTagException {
478                    return getPersistence().removeByG_N(groupId, name);
479            }
480    
481            /**
482            * Returns the number of asset tags where groupId = &#63; and name = &#63;.
483            *
484            * @param groupId the group ID
485            * @param name the name
486            * @return the number of matching asset tags
487            */
488            public static int countByG_N(long groupId, java.lang.String name) {
489                    return getPersistence().countByG_N(groupId, name);
490            }
491    
492            /**
493            * Returns all the asset tags where groupId = &#63; and name LIKE &#63;.
494            *
495            * @param groupId the group ID
496            * @param name the name
497            * @return the matching asset tags
498            */
499            public static List<AssetTag> findByG_LikeN(long groupId,
500                    java.lang.String name) {
501                    return getPersistence().findByG_LikeN(groupId, name);
502            }
503    
504            /**
505            * Returns a range of all the asset tags where groupId = &#63; and name LIKE &#63;.
506            *
507            * <p>
508            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
509            * </p>
510            *
511            * @param groupId the group ID
512            * @param name the name
513            * @param start the lower bound of the range of asset tags
514            * @param end the upper bound of the range of asset tags (not inclusive)
515            * @return the range of matching asset tags
516            */
517            public static List<AssetTag> findByG_LikeN(long groupId,
518                    java.lang.String name, int start, int end) {
519                    return getPersistence().findByG_LikeN(groupId, name, start, end);
520            }
521    
522            /**
523            * Returns an ordered range of all the asset tags where groupId = &#63; and name LIKE &#63;.
524            *
525            * <p>
526            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
527            * </p>
528            *
529            * @param groupId the group ID
530            * @param name the name
531            * @param start the lower bound of the range of asset tags
532            * @param end the upper bound of the range of asset tags (not inclusive)
533            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
534            * @return the ordered range of matching asset tags
535            */
536            public static List<AssetTag> findByG_LikeN(long groupId,
537                    java.lang.String name, int start, int end,
538                    OrderByComparator<AssetTag> orderByComparator) {
539                    return getPersistence()
540                                       .findByG_LikeN(groupId, name, start, end, orderByComparator);
541            }
542    
543            /**
544            * Returns the first asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
545            *
546            * @param groupId the group ID
547            * @param name the name
548            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
549            * @return the first matching asset tag
550            * @throws NoSuchTagException if a matching asset tag could not be found
551            */
552            public static AssetTag findByG_LikeN_First(long groupId,
553                    java.lang.String name, OrderByComparator<AssetTag> orderByComparator)
554                    throws com.liferay.portlet.asset.NoSuchTagException {
555                    return getPersistence()
556                                       .findByG_LikeN_First(groupId, name, orderByComparator);
557            }
558    
559            /**
560            * Returns the first asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
561            *
562            * @param groupId the group ID
563            * @param name the name
564            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
565            * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found
566            */
567            public static AssetTag fetchByG_LikeN_First(long groupId,
568                    java.lang.String name, OrderByComparator<AssetTag> orderByComparator) {
569                    return getPersistence()
570                                       .fetchByG_LikeN_First(groupId, name, orderByComparator);
571            }
572    
573            /**
574            * Returns the last asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
575            *
576            * @param groupId the group ID
577            * @param name the name
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the last matching asset tag
580            * @throws NoSuchTagException if a matching asset tag could not be found
581            */
582            public static AssetTag findByG_LikeN_Last(long groupId,
583                    java.lang.String name, OrderByComparator<AssetTag> orderByComparator)
584                    throws com.liferay.portlet.asset.NoSuchTagException {
585                    return getPersistence()
586                                       .findByG_LikeN_Last(groupId, name, orderByComparator);
587            }
588    
589            /**
590            * Returns the last asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
591            *
592            * @param groupId the group ID
593            * @param name the name
594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
595            * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found
596            */
597            public static AssetTag fetchByG_LikeN_Last(long groupId,
598                    java.lang.String name, OrderByComparator<AssetTag> orderByComparator) {
599                    return getPersistence()
600                                       .fetchByG_LikeN_Last(groupId, name, orderByComparator);
601            }
602    
603            /**
604            * Returns the asset tags before and after the current asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
605            *
606            * @param tagId the primary key of the current asset tag
607            * @param groupId the group ID
608            * @param name the name
609            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
610            * @return the previous, current, and next asset tag
611            * @throws NoSuchTagException if a asset tag with the primary key could not be found
612            */
613            public static AssetTag[] findByG_LikeN_PrevAndNext(long tagId,
614                    long groupId, java.lang.String name,
615                    OrderByComparator<AssetTag> orderByComparator)
616                    throws com.liferay.portlet.asset.NoSuchTagException {
617                    return getPersistence()
618                                       .findByG_LikeN_PrevAndNext(tagId, groupId, name,
619                            orderByComparator);
620            }
621    
622            /**
623            * Returns all the asset tags that the user has permission to view where groupId = &#63; and name LIKE &#63;.
624            *
625            * @param groupId the group ID
626            * @param name the name
627            * @return the matching asset tags that the user has permission to view
628            */
629            public static List<AssetTag> filterFindByG_LikeN(long groupId,
630                    java.lang.String name) {
631                    return getPersistence().filterFindByG_LikeN(groupId, name);
632            }
633    
634            /**
635            * Returns a range of all the asset tags that the user has permission to view where groupId = &#63; and name LIKE &#63;.
636            *
637            * <p>
638            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
639            * </p>
640            *
641            * @param groupId the group ID
642            * @param name the name
643            * @param start the lower bound of the range of asset tags
644            * @param end the upper bound of the range of asset tags (not inclusive)
645            * @return the range of matching asset tags that the user has permission to view
646            */
647            public static List<AssetTag> filterFindByG_LikeN(long groupId,
648                    java.lang.String name, int start, int end) {
649                    return getPersistence().filterFindByG_LikeN(groupId, name, start, end);
650            }
651    
652            /**
653            * Returns an ordered range of all the asset tags that the user has permissions to view where groupId = &#63; and name LIKE &#63;.
654            *
655            * <p>
656            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
657            * </p>
658            *
659            * @param groupId the group ID
660            * @param name the name
661            * @param start the lower bound of the range of asset tags
662            * @param end the upper bound of the range of asset tags (not inclusive)
663            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
664            * @return the ordered range of matching asset tags that the user has permission to view
665            */
666            public static List<AssetTag> filterFindByG_LikeN(long groupId,
667                    java.lang.String name, int start, int end,
668                    OrderByComparator<AssetTag> orderByComparator) {
669                    return getPersistence()
670                                       .filterFindByG_LikeN(groupId, name, start, end,
671                            orderByComparator);
672            }
673    
674            /**
675            * Returns the asset tags before and after the current asset tag in the ordered set of asset tags that the user has permission to view where groupId = &#63; and name LIKE &#63;.
676            *
677            * @param tagId the primary key of the current asset tag
678            * @param groupId the group ID
679            * @param name the name
680            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
681            * @return the previous, current, and next asset tag
682            * @throws NoSuchTagException if a asset tag with the primary key could not be found
683            */
684            public static AssetTag[] filterFindByG_LikeN_PrevAndNext(long tagId,
685                    long groupId, java.lang.String name,
686                    OrderByComparator<AssetTag> orderByComparator)
687                    throws com.liferay.portlet.asset.NoSuchTagException {
688                    return getPersistence()
689                                       .filterFindByG_LikeN_PrevAndNext(tagId, groupId, name,
690                            orderByComparator);
691            }
692    
693            /**
694            * Returns all the asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
695            *
696            * @param groupIds the group IDs
697            * @param name the name
698            * @return the matching asset tags that the user has permission to view
699            */
700            public static List<AssetTag> filterFindByG_LikeN(long[] groupIds,
701                    java.lang.String name) {
702                    return getPersistence().filterFindByG_LikeN(groupIds, name);
703            }
704    
705            /**
706            * Returns a range of all the asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
707            *
708            * <p>
709            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
710            * </p>
711            *
712            * @param groupIds the group IDs
713            * @param name the name
714            * @param start the lower bound of the range of asset tags
715            * @param end the upper bound of the range of asset tags (not inclusive)
716            * @return the range of matching asset tags that the user has permission to view
717            */
718            public static List<AssetTag> filterFindByG_LikeN(long[] groupIds,
719                    java.lang.String name, int start, int end) {
720                    return getPersistence().filterFindByG_LikeN(groupIds, name, start, end);
721            }
722    
723            /**
724            * Returns an ordered range of all the asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
725            *
726            * <p>
727            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
728            * </p>
729            *
730            * @param groupIds the group IDs
731            * @param name the name
732            * @param start the lower bound of the range of asset tags
733            * @param end the upper bound of the range of asset tags (not inclusive)
734            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
735            * @return the ordered range of matching asset tags that the user has permission to view
736            */
737            public static List<AssetTag> filterFindByG_LikeN(long[] groupIds,
738                    java.lang.String name, int start, int end,
739                    OrderByComparator<AssetTag> orderByComparator) {
740                    return getPersistence()
741                                       .filterFindByG_LikeN(groupIds, name, start, end,
742                            orderByComparator);
743            }
744    
745            /**
746            * Returns all the asset tags where groupId = any &#63; and name LIKE &#63;.
747            *
748            * <p>
749            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
750            * </p>
751            *
752            * @param groupIds the group IDs
753            * @param name the name
754            * @return the matching asset tags
755            */
756            public static List<AssetTag> findByG_LikeN(long[] groupIds,
757                    java.lang.String name) {
758                    return getPersistence().findByG_LikeN(groupIds, name);
759            }
760    
761            /**
762            * Returns a range of all the asset tags where groupId = any &#63; and name LIKE &#63;.
763            *
764            * <p>
765            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
766            * </p>
767            *
768            * @param groupIds the group IDs
769            * @param name the name
770            * @param start the lower bound of the range of asset tags
771            * @param end the upper bound of the range of asset tags (not inclusive)
772            * @return the range of matching asset tags
773            */
774            public static List<AssetTag> findByG_LikeN(long[] groupIds,
775                    java.lang.String name, int start, int end) {
776                    return getPersistence().findByG_LikeN(groupIds, name, start, end);
777            }
778    
779            /**
780            * Returns an ordered range of all the asset tags where groupId = any &#63; and name LIKE &#63;.
781            *
782            * <p>
783            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
784            * </p>
785            *
786            * @param groupIds the group IDs
787            * @param name the name
788            * @param start the lower bound of the range of asset tags
789            * @param end the upper bound of the range of asset tags (not inclusive)
790            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
791            * @return the ordered range of matching asset tags
792            */
793            public static List<AssetTag> findByG_LikeN(long[] groupIds,
794                    java.lang.String name, int start, int end,
795                    OrderByComparator<AssetTag> orderByComparator) {
796                    return getPersistence()
797                                       .findByG_LikeN(groupIds, name, start, end, orderByComparator);
798            }
799    
800            /**
801            * Removes all the asset tags where groupId = &#63; and name LIKE &#63; from the database.
802            *
803            * @param groupId the group ID
804            * @param name the name
805            */
806            public static void removeByG_LikeN(long groupId, java.lang.String name) {
807                    getPersistence().removeByG_LikeN(groupId, name);
808            }
809    
810            /**
811            * Returns the number of asset tags where groupId = &#63; and name LIKE &#63;.
812            *
813            * @param groupId the group ID
814            * @param name the name
815            * @return the number of matching asset tags
816            */
817            public static int countByG_LikeN(long groupId, java.lang.String name) {
818                    return getPersistence().countByG_LikeN(groupId, name);
819            }
820    
821            /**
822            * Returns the number of asset tags where groupId = any &#63; and name LIKE &#63;.
823            *
824            * @param groupIds the group IDs
825            * @param name the name
826            * @return the number of matching asset tags
827            */
828            public static int countByG_LikeN(long[] groupIds, java.lang.String name) {
829                    return getPersistence().countByG_LikeN(groupIds, name);
830            }
831    
832            /**
833            * Returns the number of asset tags that the user has permission to view where groupId = &#63; and name LIKE &#63;.
834            *
835            * @param groupId the group ID
836            * @param name the name
837            * @return the number of matching asset tags that the user has permission to view
838            */
839            public static int filterCountByG_LikeN(long groupId, java.lang.String name) {
840                    return getPersistence().filterCountByG_LikeN(groupId, name);
841            }
842    
843            /**
844            * Returns the number of asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
845            *
846            * @param groupIds the group IDs
847            * @param name the name
848            * @return the number of matching asset tags that the user has permission to view
849            */
850            public static int filterCountByG_LikeN(long[] groupIds,
851                    java.lang.String name) {
852                    return getPersistence().filterCountByG_LikeN(groupIds, name);
853            }
854    
855            /**
856            * Caches the asset tag in the entity cache if it is enabled.
857            *
858            * @param assetTag the asset tag
859            */
860            public static void cacheResult(AssetTag assetTag) {
861                    getPersistence().cacheResult(assetTag);
862            }
863    
864            /**
865            * Caches the asset tags in the entity cache if it is enabled.
866            *
867            * @param assetTags the asset tags
868            */
869            public static void cacheResult(List<AssetTag> assetTags) {
870                    getPersistence().cacheResult(assetTags);
871            }
872    
873            /**
874            * Creates a new asset tag with the primary key. Does not add the asset tag to the database.
875            *
876            * @param tagId the primary key for the new asset tag
877            * @return the new asset tag
878            */
879            public static AssetTag create(long tagId) {
880                    return getPersistence().create(tagId);
881            }
882    
883            /**
884            * Removes the asset tag with the primary key from the database. Also notifies the appropriate model listeners.
885            *
886            * @param tagId the primary key of the asset tag
887            * @return the asset tag that was removed
888            * @throws NoSuchTagException if a asset tag with the primary key could not be found
889            */
890            public static AssetTag remove(long tagId)
891                    throws com.liferay.portlet.asset.NoSuchTagException {
892                    return getPersistence().remove(tagId);
893            }
894    
895            public static AssetTag updateImpl(AssetTag assetTag) {
896                    return getPersistence().updateImpl(assetTag);
897            }
898    
899            /**
900            * Returns the asset tag with the primary key or throws a {@link NoSuchTagException} if it could not be found.
901            *
902            * @param tagId the primary key of the asset tag
903            * @return the asset tag
904            * @throws NoSuchTagException if a asset tag with the primary key could not be found
905            */
906            public static AssetTag findByPrimaryKey(long tagId)
907                    throws com.liferay.portlet.asset.NoSuchTagException {
908                    return getPersistence().findByPrimaryKey(tagId);
909            }
910    
911            /**
912            * Returns the asset tag with the primary key or returns <code>null</code> if it could not be found.
913            *
914            * @param tagId the primary key of the asset tag
915            * @return the asset tag, or <code>null</code> if a asset tag with the primary key could not be found
916            */
917            public static AssetTag fetchByPrimaryKey(long tagId) {
918                    return getPersistence().fetchByPrimaryKey(tagId);
919            }
920    
921            public static java.util.Map<java.io.Serializable, AssetTag> fetchByPrimaryKeys(
922                    java.util.Set<java.io.Serializable> primaryKeys) {
923                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
924            }
925    
926            /**
927            * Returns all the asset tags.
928            *
929            * @return the asset tags
930            */
931            public static List<AssetTag> findAll() {
932                    return getPersistence().findAll();
933            }
934    
935            /**
936            * Returns a range of all the asset tags.
937            *
938            * <p>
939            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
940            * </p>
941            *
942            * @param start the lower bound of the range of asset tags
943            * @param end the upper bound of the range of asset tags (not inclusive)
944            * @return the range of asset tags
945            */
946            public static List<AssetTag> findAll(int start, int end) {
947                    return getPersistence().findAll(start, end);
948            }
949    
950            /**
951            * Returns an ordered range of all the asset tags.
952            *
953            * <p>
954            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
955            * </p>
956            *
957            * @param start the lower bound of the range of asset tags
958            * @param end the upper bound of the range of asset tags (not inclusive)
959            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
960            * @return the ordered range of asset tags
961            */
962            public static List<AssetTag> findAll(int start, int end,
963                    OrderByComparator<AssetTag> orderByComparator) {
964                    return getPersistence().findAll(start, end, orderByComparator);
965            }
966    
967            /**
968            * Removes all the asset tags from the database.
969            */
970            public static void removeAll() {
971                    getPersistence().removeAll();
972            }
973    
974            /**
975            * Returns the number of asset tags.
976            *
977            * @return the number of asset tags
978            */
979            public static int countAll() {
980                    return getPersistence().countAll();
981            }
982    
983            /**
984            * Returns the primaryKeys of asset entries associated with the asset tag.
985            *
986            * @param pk the primary key of the asset tag
987            * @return long[] of the primaryKeys of asset entries associated with the asset tag
988            */
989            public static long[] getAssetEntryPrimaryKeys(long pk) {
990                    return getPersistence().getAssetEntryPrimaryKeys(pk);
991            }
992    
993            /**
994            * Returns all the asset entries associated with the asset tag.
995            *
996            * @param pk the primary key of the asset tag
997            * @return the asset entries associated with the asset tag
998            */
999            public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
1000                    long pk) {
1001                    return getPersistence().getAssetEntries(pk);
1002            }
1003    
1004            /**
1005            * Returns a range of all the asset entries associated with the asset tag.
1006            *
1007            * <p>
1008            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
1009            * </p>
1010            *
1011            * @param pk the primary key of the asset tag
1012            * @param start the lower bound of the range of asset tags
1013            * @param end the upper bound of the range of asset tags (not inclusive)
1014            * @return the range of asset entries associated with the asset tag
1015            */
1016            public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
1017                    long pk, int start, int end) {
1018                    return getPersistence().getAssetEntries(pk, start, end);
1019            }
1020    
1021            /**
1022            * Returns an ordered range of all the asset entries associated with the asset tag.
1023            *
1024            * <p>
1025            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetTagModelImpl}. 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.
1026            * </p>
1027            *
1028            * @param pk the primary key of the asset tag
1029            * @param start the lower bound of the range of asset tags
1030            * @param end the upper bound of the range of asset tags (not inclusive)
1031            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1032            * @return the ordered range of asset entries associated with the asset tag
1033            */
1034            public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
1035                    long pk, int start, int end,
1036                    OrderByComparator<com.liferay.portlet.asset.model.AssetEntry> orderByComparator) {
1037                    return getPersistence()
1038                                       .getAssetEntries(pk, start, end, orderByComparator);
1039            }
1040    
1041            /**
1042            * Returns the number of asset entries associated with the asset tag.
1043            *
1044            * @param pk the primary key of the asset tag
1045            * @return the number of asset entries associated with the asset tag
1046            */
1047            public static int getAssetEntriesSize(long pk) {
1048                    return getPersistence().getAssetEntriesSize(pk);
1049            }
1050    
1051            /**
1052            * Returns <code>true</code> if the asset entry is associated with the asset tag.
1053            *
1054            * @param pk the primary key of the asset tag
1055            * @param assetEntryPK the primary key of the asset entry
1056            * @return <code>true</code> if the asset entry is associated with the asset tag; <code>false</code> otherwise
1057            */
1058            public static boolean containsAssetEntry(long pk, long assetEntryPK) {
1059                    return getPersistence().containsAssetEntry(pk, assetEntryPK);
1060            }
1061    
1062            /**
1063            * Returns <code>true</code> if the asset tag has any asset entries associated with it.
1064            *
1065            * @param pk the primary key of the asset tag to check for associations with asset entries
1066            * @return <code>true</code> if the asset tag has any asset entries associated with it; <code>false</code> otherwise
1067            */
1068            public static boolean containsAssetEntries(long pk) {
1069                    return getPersistence().containsAssetEntries(pk);
1070            }
1071    
1072            /**
1073            * Adds an association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1074            *
1075            * @param pk the primary key of the asset tag
1076            * @param assetEntryPK the primary key of the asset entry
1077            */
1078            public static void addAssetEntry(long pk, long assetEntryPK) {
1079                    getPersistence().addAssetEntry(pk, assetEntryPK);
1080            }
1081    
1082            /**
1083            * Adds an association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1084            *
1085            * @param pk the primary key of the asset tag
1086            * @param assetEntry the asset entry
1087            */
1088            public static void addAssetEntry(long pk,
1089                    com.liferay.portlet.asset.model.AssetEntry assetEntry) {
1090                    getPersistence().addAssetEntry(pk, assetEntry);
1091            }
1092    
1093            /**
1094            * Adds an association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1095            *
1096            * @param pk the primary key of the asset tag
1097            * @param assetEntryPKs the primary keys of the asset entries
1098            */
1099            public static void addAssetEntries(long pk, long[] assetEntryPKs) {
1100                    getPersistence().addAssetEntries(pk, assetEntryPKs);
1101            }
1102    
1103            /**
1104            * Adds an association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1105            *
1106            * @param pk the primary key of the asset tag
1107            * @param assetEntries the asset entries
1108            */
1109            public static void addAssetEntries(long pk,
1110                    List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) {
1111                    getPersistence().addAssetEntries(pk, assetEntries);
1112            }
1113    
1114            /**
1115            * Clears all associations between the asset tag and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1116            *
1117            * @param pk the primary key of the asset tag to clear the associated asset entries from
1118            */
1119            public static void clearAssetEntries(long pk) {
1120                    getPersistence().clearAssetEntries(pk);
1121            }
1122    
1123            /**
1124            * Removes the association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1125            *
1126            * @param pk the primary key of the asset tag
1127            * @param assetEntryPK the primary key of the asset entry
1128            */
1129            public static void removeAssetEntry(long pk, long assetEntryPK) {
1130                    getPersistence().removeAssetEntry(pk, assetEntryPK);
1131            }
1132    
1133            /**
1134            * Removes the association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1135            *
1136            * @param pk the primary key of the asset tag
1137            * @param assetEntry the asset entry
1138            */
1139            public static void removeAssetEntry(long pk,
1140                    com.liferay.portlet.asset.model.AssetEntry assetEntry) {
1141                    getPersistence().removeAssetEntry(pk, assetEntry);
1142            }
1143    
1144            /**
1145            * Removes the association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1146            *
1147            * @param pk the primary key of the asset tag
1148            * @param assetEntryPKs the primary keys of the asset entries
1149            */
1150            public static void removeAssetEntries(long pk, long[] assetEntryPKs) {
1151                    getPersistence().removeAssetEntries(pk, assetEntryPKs);
1152            }
1153    
1154            /**
1155            * Removes the association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1156            *
1157            * @param pk the primary key of the asset tag
1158            * @param assetEntries the asset entries
1159            */
1160            public static void removeAssetEntries(long pk,
1161                    List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) {
1162                    getPersistence().removeAssetEntries(pk, assetEntries);
1163            }
1164    
1165            /**
1166            * Sets the asset entries associated with the asset tag, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1167            *
1168            * @param pk the primary key of the asset tag
1169            * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset tag
1170            */
1171            public static void setAssetEntries(long pk, long[] assetEntryPKs) {
1172                    getPersistence().setAssetEntries(pk, assetEntryPKs);
1173            }
1174    
1175            /**
1176            * Sets the asset entries associated with the asset tag, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1177            *
1178            * @param pk the primary key of the asset tag
1179            * @param assetEntries the asset entries to be associated with the asset tag
1180            */
1181            public static void setAssetEntries(long pk,
1182                    List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) {
1183                    getPersistence().setAssetEntries(pk, assetEntries);
1184            }
1185    
1186            public static AssetTagPersistence getPersistence() {
1187                    if (_persistence == null) {
1188                            _persistence = (AssetTagPersistence)PortalBeanLocatorUtil.locate(AssetTagPersistence.class.getName());
1189    
1190                            ReferenceRegistry.registerReference(AssetTagUtil.class,
1191                                    "_persistence");
1192                    }
1193    
1194                    return _persistence;
1195            }
1196    
1197            /**
1198             * @deprecated As of 6.2.0
1199             */
1200            @Deprecated
1201            public void setPersistence(AssetTagPersistence persistence) {
1202            }
1203    
1204            private static AssetTagPersistence _persistence;
1205    }