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