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.model.AssetTag;
022    
023    /**
024     * The persistence interface for the asset tag service.
025     *
026     * <p>
027     * Caching information and settings can be found in <code>portal.properties</code>
028     * </p>
029     *
030     * @author Brian Wing Shun Chan
031     * @see com.liferay.portlet.asset.service.persistence.impl.AssetTagPersistenceImpl
032     * @see AssetTagUtil
033     * @generated
034     */
035    @ProviderType
036    public interface AssetTagPersistence extends BasePersistence<AssetTag> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * 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.
041             */
042    
043            /**
044            * Returns all the asset tags where groupId = &#63;.
045            *
046            * @param groupId the group ID
047            * @return the matching asset tags
048            */
049            public java.util.List<AssetTag> findByGroupId(long groupId);
050    
051            /**
052            * Returns a range of all the asset tags where groupId = &#63;.
053            *
054            * <p>
055            * 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.
056            * </p>
057            *
058            * @param groupId the group ID
059            * @param start the lower bound of the range of asset tags
060            * @param end the upper bound of the range of asset tags (not inclusive)
061            * @return the range of matching asset tags
062            */
063            public java.util.List<AssetTag> findByGroupId(long groupId, int start,
064                    int end);
065    
066            /**
067            * Returns an ordered range of all the asset tags where groupId = &#63;.
068            *
069            * <p>
070            * 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.
071            * </p>
072            *
073            * @param groupId the group ID
074            * @param start the lower bound of the range of asset tags
075            * @param end the upper bound of the range of asset tags (not inclusive)
076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
077            * @return the ordered range of matching asset tags
078            */
079            public java.util.List<AssetTag> findByGroupId(long groupId, int start,
080                    int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
082    
083            /**
084            * Returns the first asset tag in the ordered set where groupId = &#63;.
085            *
086            * @param groupId the group ID
087            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
088            * @return the first matching asset tag
089            * @throws NoSuchTagException if a matching asset tag could not be found
090            */
091            public AssetTag findByGroupId_First(long groupId,
092                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator)
093                    throws com.liferay.portlet.asset.NoSuchTagException;
094    
095            /**
096            * Returns the first asset tag in the ordered set where groupId = &#63;.
097            *
098            * @param groupId the group ID
099            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
100            * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found
101            */
102            public AssetTag fetchByGroupId_First(long groupId,
103                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
104    
105            /**
106            * Returns the last asset tag in the ordered set where groupId = &#63;.
107            *
108            * @param groupId the group ID
109            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
110            * @return the last matching asset tag
111            * @throws NoSuchTagException if a matching asset tag could not be found
112            */
113            public AssetTag findByGroupId_Last(long groupId,
114                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator)
115                    throws com.liferay.portlet.asset.NoSuchTagException;
116    
117            /**
118            * Returns the last asset tag in the ordered set where groupId = &#63;.
119            *
120            * @param groupId the group ID
121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
122            * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found
123            */
124            public AssetTag fetchByGroupId_Last(long groupId,
125                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
126    
127            /**
128            * Returns the asset tags before and after the current asset tag in the ordered set where groupId = &#63;.
129            *
130            * @param tagId the primary key of the current asset tag
131            * @param groupId the group ID
132            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
133            * @return the previous, current, and next asset tag
134            * @throws NoSuchTagException if a asset tag with the primary key could not be found
135            */
136            public AssetTag[] findByGroupId_PrevAndNext(long tagId, long groupId,
137                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator)
138                    throws com.liferay.portlet.asset.NoSuchTagException;
139    
140            /**
141            * Returns all the asset tags that the user has permission to view where groupId = &#63;.
142            *
143            * @param groupId the group ID
144            * @return the matching asset tags that the user has permission to view
145            */
146            public java.util.List<AssetTag> filterFindByGroupId(long groupId);
147    
148            /**
149            * Returns a range of all the asset tags that the user has permission to view where groupId = &#63;.
150            *
151            * <p>
152            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.
153            * </p>
154            *
155            * @param groupId the group ID
156            * @param start the lower bound of the range of asset tags
157            * @param end the upper bound of the range of asset tags (not inclusive)
158            * @return the range of matching asset tags that the user has permission to view
159            */
160            public java.util.List<AssetTag> filterFindByGroupId(long groupId,
161                    int start, int end);
162    
163            /**
164            * Returns an ordered range of all the asset tags that the user has permissions to view where groupId = &#63;.
165            *
166            * <p>
167            * 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.
168            * </p>
169            *
170            * @param groupId the group ID
171            * @param start the lower bound of the range of asset tags
172            * @param end the upper bound of the range of asset tags (not inclusive)
173            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
174            * @return the ordered range of matching asset tags that the user has permission to view
175            */
176            public java.util.List<AssetTag> filterFindByGroupId(long groupId,
177                    int start, int end,
178                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
179    
180            /**
181            * 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;.
182            *
183            * @param tagId the primary key of the current asset tag
184            * @param groupId the group ID
185            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
186            * @return the previous, current, and next asset tag
187            * @throws NoSuchTagException if a asset tag with the primary key could not be found
188            */
189            public AssetTag[] filterFindByGroupId_PrevAndNext(long tagId, long groupId,
190                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator)
191                    throws com.liferay.portlet.asset.NoSuchTagException;
192    
193            /**
194            * Returns all the asset tags that the user has permission to view where groupId = any &#63;.
195            *
196            * @param groupIds the group IDs
197            * @return the matching asset tags that the user has permission to view
198            */
199            public java.util.List<AssetTag> filterFindByGroupId(long[] groupIds);
200    
201            /**
202            * Returns a range of all the asset tags that the user has permission to view where groupId = any &#63;.
203            *
204            * <p>
205            * 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.
206            * </p>
207            *
208            * @param groupIds the group IDs
209            * @param start the lower bound of the range of asset tags
210            * @param end the upper bound of the range of asset tags (not inclusive)
211            * @return the range of matching asset tags that the user has permission to view
212            */
213            public java.util.List<AssetTag> filterFindByGroupId(long[] groupIds,
214                    int start, int end);
215    
216            /**
217            * Returns an ordered range of all the asset tags that the user has permission to view where groupId = any &#63;.
218            *
219            * <p>
220            * 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.
221            * </p>
222            *
223            * @param groupIds the group IDs
224            * @param start the lower bound of the range of asset tags
225            * @param end the upper bound of the range of asset tags (not inclusive)
226            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
227            * @return the ordered range of matching asset tags that the user has permission to view
228            */
229            public java.util.List<AssetTag> filterFindByGroupId(long[] groupIds,
230                    int start, int end,
231                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
232    
233            /**
234            * Returns all the asset tags where groupId = any &#63;.
235            *
236            * <p>
237            * 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.
238            * </p>
239            *
240            * @param groupIds the group IDs
241            * @return the matching asset tags
242            */
243            public java.util.List<AssetTag> findByGroupId(long[] groupIds);
244    
245            /**
246            * Returns a range of all the asset tags where groupId = any &#63;.
247            *
248            * <p>
249            * 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.
250            * </p>
251            *
252            * @param groupIds the group IDs
253            * @param start the lower bound of the range of asset tags
254            * @param end the upper bound of the range of asset tags (not inclusive)
255            * @return the range of matching asset tags
256            */
257            public java.util.List<AssetTag> findByGroupId(long[] groupIds, int start,
258                    int end);
259    
260            /**
261            * Returns an ordered range of all the asset tags where groupId = any &#63;.
262            *
263            * <p>
264            * 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.
265            * </p>
266            *
267            * @param groupIds the group IDs
268            * @param start the lower bound of the range of asset tags
269            * @param end the upper bound of the range of asset tags (not inclusive)
270            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
271            * @return the ordered range of matching asset tags
272            */
273            public java.util.List<AssetTag> findByGroupId(long[] groupIds, int start,
274                    int end,
275                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
276    
277            /**
278            * Removes all the asset tags where groupId = &#63; from the database.
279            *
280            * @param groupId the group ID
281            */
282            public void removeByGroupId(long groupId);
283    
284            /**
285            * Returns the number of asset tags where groupId = &#63;.
286            *
287            * @param groupId the group ID
288            * @return the number of matching asset tags
289            */
290            public int countByGroupId(long groupId);
291    
292            /**
293            * Returns the number of asset tags where groupId = any &#63;.
294            *
295            * @param groupIds the group IDs
296            * @return the number of matching asset tags
297            */
298            public int countByGroupId(long[] groupIds);
299    
300            /**
301            * Returns the number of asset tags that the user has permission to view where groupId = &#63;.
302            *
303            * @param groupId the group ID
304            * @return the number of matching asset tags that the user has permission to view
305            */
306            public int filterCountByGroupId(long groupId);
307    
308            /**
309            * Returns the number of asset tags that the user has permission to view where groupId = any &#63;.
310            *
311            * @param groupIds the group IDs
312            * @return the number of matching asset tags that the user has permission to view
313            */
314            public int filterCountByGroupId(long[] groupIds);
315    
316            /**
317            * Returns the asset tag where groupId = &#63; and name = &#63; or throws a {@link NoSuchTagException} if it could not be found.
318            *
319            * @param groupId the group ID
320            * @param name the name
321            * @return the matching asset tag
322            * @throws NoSuchTagException if a matching asset tag could not be found
323            */
324            public AssetTag findByG_N(long groupId, java.lang.String name)
325                    throws com.liferay.portlet.asset.NoSuchTagException;
326    
327            /**
328            * 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.
329            *
330            * @param groupId the group ID
331            * @param name the name
332            * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found
333            */
334            public AssetTag fetchByG_N(long groupId, java.lang.String name);
335    
336            /**
337            * 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.
338            *
339            * @param groupId the group ID
340            * @param name the name
341            * @param retrieveFromCache whether to use the finder cache
342            * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found
343            */
344            public AssetTag fetchByG_N(long groupId, java.lang.String name,
345                    boolean retrieveFromCache);
346    
347            /**
348            * Removes the asset tag where groupId = &#63; and name = &#63; from the database.
349            *
350            * @param groupId the group ID
351            * @param name the name
352            * @return the asset tag that was removed
353            */
354            public AssetTag removeByG_N(long groupId, java.lang.String name)
355                    throws com.liferay.portlet.asset.NoSuchTagException;
356    
357            /**
358            * Returns the number of asset tags where groupId = &#63; and name = &#63;.
359            *
360            * @param groupId the group ID
361            * @param name the name
362            * @return the number of matching asset tags
363            */
364            public int countByG_N(long groupId, java.lang.String name);
365    
366            /**
367            * Returns all the asset tags where groupId = &#63; and name LIKE &#63;.
368            *
369            * @param groupId the group ID
370            * @param name the name
371            * @return the matching asset tags
372            */
373            public java.util.List<AssetTag> findByG_LikeN(long groupId,
374                    java.lang.String name);
375    
376            /**
377            * Returns a range of all the asset tags where groupId = &#63; and name LIKE &#63;.
378            *
379            * <p>
380            * 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.
381            * </p>
382            *
383            * @param groupId the group ID
384            * @param name the name
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> findByG_LikeN(long groupId,
390                    java.lang.String name, int start, int end);
391    
392            /**
393            * Returns an ordered range of all the asset tags where groupId = &#63; and name LIKE &#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 name the name
401            * @param start the lower bound of the range of asset tags
402            * @param end the upper bound of the range of asset tags (not inclusive)
403            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
404            * @return the ordered range of matching asset tags
405            */
406            public java.util.List<AssetTag> findByG_LikeN(long groupId,
407                    java.lang.String name, int start, int end,
408                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
409    
410            /**
411            * Returns the first asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
412            *
413            * @param groupId the group ID
414            * @param name the name
415            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
416            * @return the first matching asset tag
417            * @throws NoSuchTagException if a matching asset tag could not be found
418            */
419            public AssetTag findByG_LikeN_First(long groupId, java.lang.String name,
420                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator)
421                    throws com.liferay.portlet.asset.NoSuchTagException;
422    
423            /**
424            * Returns the first asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
425            *
426            * @param groupId the group ID
427            * @param name the name
428            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
429            * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found
430            */
431            public AssetTag fetchByG_LikeN_First(long groupId, java.lang.String name,
432                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
433    
434            /**
435            * Returns the last asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
436            *
437            * @param groupId the group ID
438            * @param name the name
439            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
440            * @return the last matching asset tag
441            * @throws NoSuchTagException if a matching asset tag could not be found
442            */
443            public AssetTag findByG_LikeN_Last(long groupId, java.lang.String name,
444                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator)
445                    throws com.liferay.portlet.asset.NoSuchTagException;
446    
447            /**
448            * Returns the last asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
449            *
450            * @param groupId the group ID
451            * @param name the name
452            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
453            * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found
454            */
455            public AssetTag fetchByG_LikeN_Last(long groupId, java.lang.String name,
456                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
457    
458            /**
459            * Returns the asset tags before and after the current asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
460            *
461            * @param tagId the primary key of the current asset tag
462            * @param groupId the group ID
463            * @param name the name
464            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
465            * @return the previous, current, and next asset tag
466            * @throws NoSuchTagException if a asset tag with the primary key could not be found
467            */
468            public AssetTag[] findByG_LikeN_PrevAndNext(long tagId, long groupId,
469                    java.lang.String name,
470                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator)
471                    throws com.liferay.portlet.asset.NoSuchTagException;
472    
473            /**
474            * Returns all the asset tags that the user has permission to view where groupId = &#63; and name LIKE &#63;.
475            *
476            * @param groupId the group ID
477            * @param name the name
478            * @return the matching asset tags that the user has permission to view
479            */
480            public java.util.List<AssetTag> filterFindByG_LikeN(long groupId,
481                    java.lang.String name);
482    
483            /**
484            * Returns a range of all the asset tags that the user has permission to view where groupId = &#63; and name LIKE &#63;.
485            *
486            * <p>
487            * 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.
488            * </p>
489            *
490            * @param groupId the group ID
491            * @param name the name
492            * @param start the lower bound of the range of asset tags
493            * @param end the upper bound of the range of asset tags (not inclusive)
494            * @return the range of matching asset tags that the user has permission to view
495            */
496            public java.util.List<AssetTag> filterFindByG_LikeN(long groupId,
497                    java.lang.String name, int start, int end);
498    
499            /**
500            * Returns an ordered range of all the asset tags that the user has permissions to view where groupId = &#63; and name LIKE &#63;.
501            *
502            * <p>
503            * 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.
504            * </p>
505            *
506            * @param groupId the group ID
507            * @param name the name
508            * @param start the lower bound of the range of asset tags
509            * @param end the upper bound of the range of asset tags (not inclusive)
510            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
511            * @return the ordered range of matching asset tags that the user has permission to view
512            */
513            public java.util.List<AssetTag> filterFindByG_LikeN(long groupId,
514                    java.lang.String name, int start, int end,
515                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
516    
517            /**
518            * 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;.
519            *
520            * @param tagId the primary key of the current asset tag
521            * @param groupId the group ID
522            * @param name the name
523            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
524            * @return the previous, current, and next asset tag
525            * @throws NoSuchTagException if a asset tag with the primary key could not be found
526            */
527            public AssetTag[] filterFindByG_LikeN_PrevAndNext(long tagId, long groupId,
528                    java.lang.String name,
529                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator)
530                    throws com.liferay.portlet.asset.NoSuchTagException;
531    
532            /**
533            * Returns all the asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
534            *
535            * @param groupIds the group IDs
536            * @param name the name
537            * @return the matching asset tags that the user has permission to view
538            */
539            public java.util.List<AssetTag> filterFindByG_LikeN(long[] groupIds,
540                    java.lang.String name);
541    
542            /**
543            * Returns a range of all the asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
544            *
545            * <p>
546            * 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.
547            * </p>
548            *
549            * @param groupIds the group IDs
550            * @param name the name
551            * @param start the lower bound of the range of asset tags
552            * @param end the upper bound of the range of asset tags (not inclusive)
553            * @return the range of matching asset tags that the user has permission to view
554            */
555            public java.util.List<AssetTag> filterFindByG_LikeN(long[] groupIds,
556                    java.lang.String name, int start, int end);
557    
558            /**
559            * Returns an ordered range of all the asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
560            *
561            * <p>
562            * 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.
563            * </p>
564            *
565            * @param groupIds the group IDs
566            * @param name the name
567            * @param start the lower bound of the range of asset tags
568            * @param end the upper bound of the range of asset tags (not inclusive)
569            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
570            * @return the ordered range of matching asset tags that the user has permission to view
571            */
572            public java.util.List<AssetTag> filterFindByG_LikeN(long[] groupIds,
573                    java.lang.String name, int start, int end,
574                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
575    
576            /**
577            * Returns all the asset tags where groupId = any &#63; and name LIKE &#63;.
578            *
579            * <p>
580            * 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.
581            * </p>
582            *
583            * @param groupIds the group IDs
584            * @param name the name
585            * @return the matching asset tags
586            */
587            public java.util.List<AssetTag> findByG_LikeN(long[] groupIds,
588                    java.lang.String name);
589    
590            /**
591            * Returns a range of all the asset tags where groupId = any &#63; and name LIKE &#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 name the name
599            * @param start the lower bound of the range of asset tags
600            * @param end the upper bound of the range of asset tags (not inclusive)
601            * @return the range of matching asset tags
602            */
603            public java.util.List<AssetTag> findByG_LikeN(long[] groupIds,
604                    java.lang.String name, int start, int end);
605    
606            /**
607            * Returns an ordered range of all the asset tags where groupId = any &#63; and name LIKE &#63;.
608            *
609            * <p>
610            * 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.
611            * </p>
612            *
613            * @param groupIds the group IDs
614            * @param name the name
615            * @param start the lower bound of the range of asset tags
616            * @param end the upper bound of the range of asset tags (not inclusive)
617            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
618            * @return the ordered range of matching asset tags
619            */
620            public java.util.List<AssetTag> findByG_LikeN(long[] groupIds,
621                    java.lang.String name, int start, int end,
622                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
623    
624            /**
625            * Removes all the asset tags where groupId = &#63; and name LIKE &#63; from the database.
626            *
627            * @param groupId the group ID
628            * @param name the name
629            */
630            public void removeByG_LikeN(long groupId, java.lang.String name);
631    
632            /**
633            * Returns the number of asset tags where groupId = &#63; and name LIKE &#63;.
634            *
635            * @param groupId the group ID
636            * @param name the name
637            * @return the number of matching asset tags
638            */
639            public int countByG_LikeN(long groupId, java.lang.String name);
640    
641            /**
642            * Returns the number of asset tags where groupId = any &#63; and name LIKE &#63;.
643            *
644            * @param groupIds the group IDs
645            * @param name the name
646            * @return the number of matching asset tags
647            */
648            public int countByG_LikeN(long[] groupIds, java.lang.String name);
649    
650            /**
651            * Returns the number of asset tags that the user has permission to view where groupId = &#63; and name LIKE &#63;.
652            *
653            * @param groupId the group ID
654            * @param name the name
655            * @return the number of matching asset tags that the user has permission to view
656            */
657            public int filterCountByG_LikeN(long groupId, java.lang.String name);
658    
659            /**
660            * Returns the number of asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
661            *
662            * @param groupIds the group IDs
663            * @param name the name
664            * @return the number of matching asset tags that the user has permission to view
665            */
666            public int filterCountByG_LikeN(long[] groupIds, java.lang.String name);
667    
668            /**
669            * Caches the asset tag in the entity cache if it is enabled.
670            *
671            * @param assetTag the asset tag
672            */
673            public void cacheResult(AssetTag assetTag);
674    
675            /**
676            * Caches the asset tags in the entity cache if it is enabled.
677            *
678            * @param assetTags the asset tags
679            */
680            public void cacheResult(java.util.List<AssetTag> assetTags);
681    
682            /**
683            * Creates a new asset tag with the primary key. Does not add the asset tag to the database.
684            *
685            * @param tagId the primary key for the new asset tag
686            * @return the new asset tag
687            */
688            public AssetTag create(long tagId);
689    
690            /**
691            * Removes the asset tag with the primary key from the database. Also notifies the appropriate model listeners.
692            *
693            * @param tagId the primary key of the asset tag
694            * @return the asset tag that was removed
695            * @throws NoSuchTagException if a asset tag with the primary key could not be found
696            */
697            public AssetTag remove(long tagId)
698                    throws com.liferay.portlet.asset.NoSuchTagException;
699    
700            public AssetTag updateImpl(AssetTag assetTag);
701    
702            /**
703            * Returns the asset tag with the primary key or throws a {@link NoSuchTagException} if it could not be found.
704            *
705            * @param tagId the primary key of the asset tag
706            * @return the asset tag
707            * @throws NoSuchTagException if a asset tag with the primary key could not be found
708            */
709            public AssetTag findByPrimaryKey(long tagId)
710                    throws com.liferay.portlet.asset.NoSuchTagException;
711    
712            /**
713            * Returns the asset tag with the primary key or returns <code>null</code> if it could not be found.
714            *
715            * @param tagId the primary key of the asset tag
716            * @return the asset tag, or <code>null</code> if a asset tag with the primary key could not be found
717            */
718            public AssetTag fetchByPrimaryKey(long tagId);
719    
720            @Override
721            public java.util.Map<java.io.Serializable, AssetTag> fetchByPrimaryKeys(
722                    java.util.Set<java.io.Serializable> primaryKeys);
723    
724            /**
725            * Returns all the asset tags.
726            *
727            * @return the asset tags
728            */
729            public java.util.List<AssetTag> findAll();
730    
731            /**
732            * Returns a range of all the asset tags.
733            *
734            * <p>
735            * 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.
736            * </p>
737            *
738            * @param start the lower bound of the range of asset tags
739            * @param end the upper bound of the range of asset tags (not inclusive)
740            * @return the range of asset tags
741            */
742            public java.util.List<AssetTag> findAll(int start, int end);
743    
744            /**
745            * Returns an ordered range of all the asset tags.
746            *
747            * <p>
748            * 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.
749            * </p>
750            *
751            * @param start the lower bound of the range of asset tags
752            * @param end the upper bound of the range of asset tags (not inclusive)
753            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
754            * @return the ordered range of asset tags
755            */
756            public java.util.List<AssetTag> findAll(int start, int end,
757                    com.liferay.portal.kernel.util.OrderByComparator<AssetTag> orderByComparator);
758    
759            /**
760            * Removes all the asset tags from the database.
761            */
762            public void removeAll();
763    
764            /**
765            * Returns the number of asset tags.
766            *
767            * @return the number of asset tags
768            */
769            public int countAll();
770    
771            /**
772            * Returns the primaryKeys of asset entries associated with the asset tag.
773            *
774            * @param pk the primary key of the asset tag
775            * @return long[] of the primaryKeys of asset entries associated with the asset tag
776            */
777            public long[] getAssetEntryPrimaryKeys(long pk);
778    
779            /**
780            * Returns all the asset entries associated with the asset tag.
781            *
782            * @param pk the primary key of the asset tag
783            * @return the asset entries associated with the asset tag
784            */
785            public java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
786                    long pk);
787    
788            /**
789            * Returns a range of all the asset entries associated with the asset tag.
790            *
791            * <p>
792            * 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.
793            * </p>
794            *
795            * @param pk the primary key of the asset tag
796            * @param start the lower bound of the range of asset tags
797            * @param end the upper bound of the range of asset tags (not inclusive)
798            * @return the range of asset entries associated with the asset tag
799            */
800            public java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
801                    long pk, int start, int end);
802    
803            /**
804            * Returns an ordered range of all the asset entries associated with the asset tag.
805            *
806            * <p>
807            * 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.
808            * </p>
809            *
810            * @param pk the primary key of the asset tag
811            * @param start the lower bound of the range of asset tags
812            * @param end the upper bound of the range of asset tags (not inclusive)
813            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
814            * @return the ordered range of asset entries associated with the asset tag
815            */
816            public java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
817                    long pk, int start, int end,
818                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.asset.model.AssetEntry> orderByComparator);
819    
820            /**
821            * Returns the number of asset entries associated with the asset tag.
822            *
823            * @param pk the primary key of the asset tag
824            * @return the number of asset entries associated with the asset tag
825            */
826            public int getAssetEntriesSize(long pk);
827    
828            /**
829            * Returns <code>true</code> if the asset entry is associated with the asset tag.
830            *
831            * @param pk the primary key of the asset tag
832            * @param assetEntryPK the primary key of the asset entry
833            * @return <code>true</code> if the asset entry is associated with the asset tag; <code>false</code> otherwise
834            */
835            public boolean containsAssetEntry(long pk, long assetEntryPK);
836    
837            /**
838            * Returns <code>true</code> if the asset tag has any asset entries associated with it.
839            *
840            * @param pk the primary key of the asset tag to check for associations with asset entries
841            * @return <code>true</code> if the asset tag has any asset entries associated with it; <code>false</code> otherwise
842            */
843            public boolean containsAssetEntries(long pk);
844    
845            /**
846            * Adds an association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
847            *
848            * @param pk the primary key of the asset tag
849            * @param assetEntryPK the primary key of the asset entry
850            */
851            public void addAssetEntry(long pk, long assetEntryPK);
852    
853            /**
854            * Adds an association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
855            *
856            * @param pk the primary key of the asset tag
857            * @param assetEntry the asset entry
858            */
859            public void addAssetEntry(long pk,
860                    com.liferay.portlet.asset.model.AssetEntry assetEntry);
861    
862            /**
863            * Adds an association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
864            *
865            * @param pk the primary key of the asset tag
866            * @param assetEntryPKs the primary keys of the asset entries
867            */
868            public void addAssetEntries(long pk, long[] assetEntryPKs);
869    
870            /**
871            * Adds an association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
872            *
873            * @param pk the primary key of the asset tag
874            * @param assetEntries the asset entries
875            */
876            public void addAssetEntries(long pk,
877                    java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries);
878    
879            /**
880            * Clears all associations between the asset tag and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
881            *
882            * @param pk the primary key of the asset tag to clear the associated asset entries from
883            */
884            public void clearAssetEntries(long pk);
885    
886            /**
887            * Removes the association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
888            *
889            * @param pk the primary key of the asset tag
890            * @param assetEntryPK the primary key of the asset entry
891            */
892            public void removeAssetEntry(long pk, long assetEntryPK);
893    
894            /**
895            * Removes the association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
896            *
897            * @param pk the primary key of the asset tag
898            * @param assetEntry the asset entry
899            */
900            public void removeAssetEntry(long pk,
901                    com.liferay.portlet.asset.model.AssetEntry assetEntry);
902    
903            /**
904            * Removes the association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
905            *
906            * @param pk the primary key of the asset tag
907            * @param assetEntryPKs the primary keys of the asset entries
908            */
909            public void removeAssetEntries(long pk, long[] assetEntryPKs);
910    
911            /**
912            * Removes the association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
913            *
914            * @param pk the primary key of the asset tag
915            * @param assetEntries the asset entries
916            */
917            public void removeAssetEntries(long pk,
918                    java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries);
919    
920            /**
921            * 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.
922            *
923            * @param pk the primary key of the asset tag
924            * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset tag
925            */
926            public void setAssetEntries(long pk, long[] assetEntryPKs);
927    
928            /**
929            * 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.
930            *
931            * @param pk the primary key of the asset tag
932            * @param assetEntries the asset entries to be associated with the asset tag
933            */
934            public void setAssetEntries(long pk,
935                    java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries);
936    }