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