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