001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.asset.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.asset.model.AssetEntry;
026    
027    import java.util.Date;
028    import java.util.List;
029    
030    /**
031     * The persistence utility for the asset entry service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
032     *
033     * <p>
034     * Caching information and settings can be found in <code>portal.properties</code>
035     * </p>
036     *
037     * @author Brian Wing Shun Chan
038     * @see AssetEntryPersistence
039     * @see com.liferay.portlet.asset.service.persistence.impl.AssetEntryPersistenceImpl
040     * @generated
041     */
042    @ProviderType
043    public class AssetEntryUtil {
044            /*
045             * NOTE FOR DEVELOPERS:
046             *
047             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
048             */
049    
050            /**
051             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
052             */
053            public static void clearCache() {
054                    getPersistence().clearCache();
055            }
056    
057            /**
058             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
059             */
060            public static void clearCache(AssetEntry assetEntry) {
061                    getPersistence().clearCache(assetEntry);
062            }
063    
064            /**
065             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
066             */
067            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
068                    return getPersistence().countWithDynamicQuery(dynamicQuery);
069            }
070    
071            /**
072             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
073             */
074            public static List<AssetEntry> findWithDynamicQuery(
075                    DynamicQuery dynamicQuery) {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
081             */
082            public static List<AssetEntry> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end) {
084                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
085            }
086    
087            /**
088             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
089             */
090            public static List<AssetEntry> findWithDynamicQuery(
091                    DynamicQuery dynamicQuery, int start, int end,
092                    OrderByComparator<AssetEntry> orderByComparator) {
093                    return getPersistence()
094                                       .findWithDynamicQuery(dynamicQuery, start, end,
095                            orderByComparator);
096            }
097    
098            /**
099             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
100             */
101            public static AssetEntry update(AssetEntry assetEntry) {
102                    return getPersistence().update(assetEntry);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static AssetEntry update(AssetEntry assetEntry,
109                    ServiceContext serviceContext) {
110                    return getPersistence().update(assetEntry, serviceContext);
111            }
112    
113            /**
114            * Returns all the asset entries where groupId = &#63;.
115            *
116            * @param groupId the group ID
117            * @return the matching asset entries
118            */
119            public static List<AssetEntry> findByGroupId(long groupId) {
120                    return getPersistence().findByGroupId(groupId);
121            }
122    
123            /**
124            * Returns a range of all the asset entries where groupId = &#63;.
125            *
126            * <p>
127            * 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.
128            * </p>
129            *
130            * @param groupId the group ID
131            * @param start the lower bound of the range of asset entries
132            * @param end the upper bound of the range of asset entries (not inclusive)
133            * @return the range of matching asset entries
134            */
135            public static List<AssetEntry> findByGroupId(long groupId, int start,
136                    int end) {
137                    return getPersistence().findByGroupId(groupId, start, end);
138            }
139    
140            /**
141            * Returns an ordered range of all the asset entries where groupId = &#63;.
142            *
143            * <p>
144            * 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.
145            * </p>
146            *
147            * @param groupId the group ID
148            * @param start the lower bound of the range of asset entries
149            * @param end the upper bound of the range of asset entries (not inclusive)
150            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
151            * @return the ordered range of matching asset entries
152            */
153            public static List<AssetEntry> findByGroupId(long groupId, int start,
154                    int end, OrderByComparator<AssetEntry> orderByComparator) {
155                    return getPersistence()
156                                       .findByGroupId(groupId, start, end, orderByComparator);
157            }
158    
159            /**
160            * Returns an ordered range of all the asset entries where groupId = &#63;.
161            *
162            * <p>
163            * 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.
164            * </p>
165            *
166            * @param groupId the group ID
167            * @param start the lower bound of the range of asset entries
168            * @param end the upper bound of the range of asset entries (not inclusive)
169            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
170            * @param retrieveFromCache whether to retrieve from the finder cache
171            * @return the ordered range of matching asset entries
172            */
173            public static List<AssetEntry> findByGroupId(long groupId, int start,
174                    int end, OrderByComparator<AssetEntry> orderByComparator,
175                    boolean retrieveFromCache) {
176                    return getPersistence()
177                                       .findByGroupId(groupId, start, end, orderByComparator,
178                            retrieveFromCache);
179            }
180    
181            /**
182            * Returns the first asset entry in the ordered set where groupId = &#63;.
183            *
184            * @param groupId the group ID
185            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
186            * @return the first matching asset entry
187            * @throws NoSuchEntryException if a matching asset entry could not be found
188            */
189            public static AssetEntry findByGroupId_First(long groupId,
190                    OrderByComparator<AssetEntry> orderByComparator)
191                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
192                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
193            }
194    
195            /**
196            * Returns the first asset entry in the ordered set where groupId = &#63;.
197            *
198            * @param groupId the group ID
199            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
200            * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found
201            */
202            public static AssetEntry fetchByGroupId_First(long groupId,
203                    OrderByComparator<AssetEntry> orderByComparator) {
204                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
205            }
206    
207            /**
208            * Returns the last asset entry in the ordered set where groupId = &#63;.
209            *
210            * @param groupId the group ID
211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
212            * @return the last matching asset entry
213            * @throws NoSuchEntryException if a matching asset entry could not be found
214            */
215            public static AssetEntry findByGroupId_Last(long groupId,
216                    OrderByComparator<AssetEntry> orderByComparator)
217                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
218                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
219            }
220    
221            /**
222            * Returns the last asset entry in the ordered set where groupId = &#63;.
223            *
224            * @param groupId the group ID
225            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
226            * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found
227            */
228            public static AssetEntry fetchByGroupId_Last(long groupId,
229                    OrderByComparator<AssetEntry> orderByComparator) {
230                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
231            }
232    
233            /**
234            * Returns the asset entries before and after the current asset entry in the ordered set where groupId = &#63;.
235            *
236            * @param entryId the primary key of the current asset entry
237            * @param groupId the group ID
238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
239            * @return the previous, current, and next asset entry
240            * @throws NoSuchEntryException if a asset entry with the primary key could not be found
241            */
242            public static AssetEntry[] findByGroupId_PrevAndNext(long entryId,
243                    long groupId, OrderByComparator<AssetEntry> orderByComparator)
244                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
245                    return getPersistence()
246                                       .findByGroupId_PrevAndNext(entryId, groupId,
247                            orderByComparator);
248            }
249    
250            /**
251            * Removes all the asset entries where groupId = &#63; from the database.
252            *
253            * @param groupId the group ID
254            */
255            public static void removeByGroupId(long groupId) {
256                    getPersistence().removeByGroupId(groupId);
257            }
258    
259            /**
260            * Returns the number of asset entries where groupId = &#63;.
261            *
262            * @param groupId the group ID
263            * @return the number of matching asset entries
264            */
265            public static int countByGroupId(long groupId) {
266                    return getPersistence().countByGroupId(groupId);
267            }
268    
269            /**
270            * Returns all the asset entries where companyId = &#63;.
271            *
272            * @param companyId the company ID
273            * @return the matching asset entries
274            */
275            public static List<AssetEntry> findByCompanyId(long companyId) {
276                    return getPersistence().findByCompanyId(companyId);
277            }
278    
279            /**
280            * Returns a range of all the asset entries where companyId = &#63;.
281            *
282            * <p>
283            * 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.
284            * </p>
285            *
286            * @param companyId the company ID
287            * @param start the lower bound of the range of asset entries
288            * @param end the upper bound of the range of asset entries (not inclusive)
289            * @return the range of matching asset entries
290            */
291            public static List<AssetEntry> findByCompanyId(long companyId, int start,
292                    int end) {
293                    return getPersistence().findByCompanyId(companyId, start, end);
294            }
295    
296            /**
297            * Returns an ordered range of all the asset entries where companyId = &#63;.
298            *
299            * <p>
300            * 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.
301            * </p>
302            *
303            * @param companyId the company ID
304            * @param start the lower bound of the range of asset entries
305            * @param end the upper bound of the range of asset entries (not inclusive)
306            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
307            * @return the ordered range of matching asset entries
308            */
309            public static List<AssetEntry> findByCompanyId(long companyId, int start,
310                    int end, OrderByComparator<AssetEntry> orderByComparator) {
311                    return getPersistence()
312                                       .findByCompanyId(companyId, start, end, orderByComparator);
313            }
314    
315            /**
316            * Returns an ordered range of all the asset entries where companyId = &#63;.
317            *
318            * <p>
319            * 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.
320            * </p>
321            *
322            * @param companyId the company ID
323            * @param start the lower bound of the range of asset entries
324            * @param end the upper bound of the range of asset entries (not inclusive)
325            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
326            * @param retrieveFromCache whether to retrieve from the finder cache
327            * @return the ordered range of matching asset entries
328            */
329            public static List<AssetEntry> findByCompanyId(long companyId, int start,
330                    int end, OrderByComparator<AssetEntry> orderByComparator,
331                    boolean retrieveFromCache) {
332                    return getPersistence()
333                                       .findByCompanyId(companyId, start, end, orderByComparator,
334                            retrieveFromCache);
335            }
336    
337            /**
338            * Returns the first asset entry in the ordered set where companyId = &#63;.
339            *
340            * @param companyId the company ID
341            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
342            * @return the first matching asset entry
343            * @throws NoSuchEntryException if a matching asset entry could not be found
344            */
345            public static AssetEntry findByCompanyId_First(long companyId,
346                    OrderByComparator<AssetEntry> orderByComparator)
347                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
348                    return getPersistence()
349                                       .findByCompanyId_First(companyId, orderByComparator);
350            }
351    
352            /**
353            * Returns the first asset entry in the ordered set where companyId = &#63;.
354            *
355            * @param companyId the company ID
356            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
357            * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found
358            */
359            public static AssetEntry fetchByCompanyId_First(long companyId,
360                    OrderByComparator<AssetEntry> orderByComparator) {
361                    return getPersistence()
362                                       .fetchByCompanyId_First(companyId, orderByComparator);
363            }
364    
365            /**
366            * Returns the last asset entry in the ordered set where companyId = &#63;.
367            *
368            * @param companyId the company ID
369            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
370            * @return the last matching asset entry
371            * @throws NoSuchEntryException if a matching asset entry could not be found
372            */
373            public static AssetEntry findByCompanyId_Last(long companyId,
374                    OrderByComparator<AssetEntry> orderByComparator)
375                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
376                    return getPersistence()
377                                       .findByCompanyId_Last(companyId, orderByComparator);
378            }
379    
380            /**
381            * Returns the last asset entry in the ordered set where companyId = &#63;.
382            *
383            * @param companyId the company ID
384            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
385            * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found
386            */
387            public static AssetEntry fetchByCompanyId_Last(long companyId,
388                    OrderByComparator<AssetEntry> orderByComparator) {
389                    return getPersistence()
390                                       .fetchByCompanyId_Last(companyId, orderByComparator);
391            }
392    
393            /**
394            * Returns the asset entries before and after the current asset entry in the ordered set where companyId = &#63;.
395            *
396            * @param entryId the primary key of the current asset entry
397            * @param companyId the company ID
398            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
399            * @return the previous, current, and next asset entry
400            * @throws NoSuchEntryException if a asset entry with the primary key could not be found
401            */
402            public static AssetEntry[] findByCompanyId_PrevAndNext(long entryId,
403                    long companyId, OrderByComparator<AssetEntry> orderByComparator)
404                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
405                    return getPersistence()
406                                       .findByCompanyId_PrevAndNext(entryId, companyId,
407                            orderByComparator);
408            }
409    
410            /**
411            * Removes all the asset entries where companyId = &#63; from the database.
412            *
413            * @param companyId the company ID
414            */
415            public static void removeByCompanyId(long companyId) {
416                    getPersistence().removeByCompanyId(companyId);
417            }
418    
419            /**
420            * Returns the number of asset entries where companyId = &#63;.
421            *
422            * @param companyId the company ID
423            * @return the number of matching asset entries
424            */
425            public static int countByCompanyId(long companyId) {
426                    return getPersistence().countByCompanyId(companyId);
427            }
428    
429            /**
430            * Returns all the asset entries where visible = &#63;.
431            *
432            * @param visible the visible
433            * @return the matching asset entries
434            */
435            public static List<AssetEntry> findByVisible(boolean visible) {
436                    return getPersistence().findByVisible(visible);
437            }
438    
439            /**
440            * Returns a range of all the asset entries where visible = &#63;.
441            *
442            * <p>
443            * 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.
444            * </p>
445            *
446            * @param visible the visible
447            * @param start the lower bound of the range of asset entries
448            * @param end the upper bound of the range of asset entries (not inclusive)
449            * @return the range of matching asset entries
450            */
451            public static List<AssetEntry> findByVisible(boolean visible, int start,
452                    int end) {
453                    return getPersistence().findByVisible(visible, start, end);
454            }
455    
456            /**
457            * Returns an ordered range of all the asset entries where visible = &#63;.
458            *
459            * <p>
460            * 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.
461            * </p>
462            *
463            * @param visible the visible
464            * @param start the lower bound of the range of asset entries
465            * @param end the upper bound of the range of asset entries (not inclusive)
466            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
467            * @return the ordered range of matching asset entries
468            */
469            public static List<AssetEntry> findByVisible(boolean visible, int start,
470                    int end, OrderByComparator<AssetEntry> orderByComparator) {
471                    return getPersistence()
472                                       .findByVisible(visible, start, end, orderByComparator);
473            }
474    
475            /**
476            * Returns an ordered range of all the asset entries where visible = &#63;.
477            *
478            * <p>
479            * 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.
480            * </p>
481            *
482            * @param visible the visible
483            * @param start the lower bound of the range of asset entries
484            * @param end the upper bound of the range of asset entries (not inclusive)
485            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
486            * @param retrieveFromCache whether to retrieve from the finder cache
487            * @return the ordered range of matching asset entries
488            */
489            public static List<AssetEntry> findByVisible(boolean visible, int start,
490                    int end, OrderByComparator<AssetEntry> orderByComparator,
491                    boolean retrieveFromCache) {
492                    return getPersistence()
493                                       .findByVisible(visible, start, end, orderByComparator,
494                            retrieveFromCache);
495            }
496    
497            /**
498            * Returns the first asset entry in the ordered set where visible = &#63;.
499            *
500            * @param visible the visible
501            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
502            * @return the first matching asset entry
503            * @throws NoSuchEntryException if a matching asset entry could not be found
504            */
505            public static AssetEntry findByVisible_First(boolean visible,
506                    OrderByComparator<AssetEntry> orderByComparator)
507                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
508                    return getPersistence().findByVisible_First(visible, orderByComparator);
509            }
510    
511            /**
512            * Returns the first asset entry in the ordered set where visible = &#63;.
513            *
514            * @param visible the visible
515            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
516            * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found
517            */
518            public static AssetEntry fetchByVisible_First(boolean visible,
519                    OrderByComparator<AssetEntry> orderByComparator) {
520                    return getPersistence().fetchByVisible_First(visible, orderByComparator);
521            }
522    
523            /**
524            * Returns the last asset entry in the ordered set where visible = &#63;.
525            *
526            * @param visible the visible
527            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
528            * @return the last matching asset entry
529            * @throws NoSuchEntryException if a matching asset entry could not be found
530            */
531            public static AssetEntry findByVisible_Last(boolean visible,
532                    OrderByComparator<AssetEntry> orderByComparator)
533                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
534                    return getPersistence().findByVisible_Last(visible, orderByComparator);
535            }
536    
537            /**
538            * Returns the last asset entry in the ordered set where visible = &#63;.
539            *
540            * @param visible the visible
541            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
542            * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found
543            */
544            public static AssetEntry fetchByVisible_Last(boolean visible,
545                    OrderByComparator<AssetEntry> orderByComparator) {
546                    return getPersistence().fetchByVisible_Last(visible, orderByComparator);
547            }
548    
549            /**
550            * Returns the asset entries before and after the current asset entry in the ordered set where visible = &#63;.
551            *
552            * @param entryId the primary key of the current asset entry
553            * @param visible the visible
554            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
555            * @return the previous, current, and next asset entry
556            * @throws NoSuchEntryException if a asset entry with the primary key could not be found
557            */
558            public static AssetEntry[] findByVisible_PrevAndNext(long entryId,
559                    boolean visible, OrderByComparator<AssetEntry> orderByComparator)
560                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
561                    return getPersistence()
562                                       .findByVisible_PrevAndNext(entryId, visible,
563                            orderByComparator);
564            }
565    
566            /**
567            * Removes all the asset entries where visible = &#63; from the database.
568            *
569            * @param visible the visible
570            */
571            public static void removeByVisible(boolean visible) {
572                    getPersistence().removeByVisible(visible);
573            }
574    
575            /**
576            * Returns the number of asset entries where visible = &#63;.
577            *
578            * @param visible the visible
579            * @return the number of matching asset entries
580            */
581            public static int countByVisible(boolean visible) {
582                    return getPersistence().countByVisible(visible);
583            }
584    
585            /**
586            * Returns all the asset entries where publishDate = &#63;.
587            *
588            * @param publishDate the publish date
589            * @return the matching asset entries
590            */
591            public static List<AssetEntry> findByPublishDate(Date publishDate) {
592                    return getPersistence().findByPublishDate(publishDate);
593            }
594    
595            /**
596            * Returns a range of all the asset entries where publishDate = &#63;.
597            *
598            * <p>
599            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
600            * </p>
601            *
602            * @param publishDate the publish date
603            * @param start the lower bound of the range of asset entries
604            * @param end the upper bound of the range of asset entries (not inclusive)
605            * @return the range of matching asset entries
606            */
607            public static List<AssetEntry> findByPublishDate(Date publishDate,
608                    int start, int end) {
609                    return getPersistence().findByPublishDate(publishDate, start, end);
610            }
611    
612            /**
613            * Returns an ordered range of all the asset entries where publishDate = &#63;.
614            *
615            * <p>
616            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
617            * </p>
618            *
619            * @param publishDate the publish date
620            * @param start the lower bound of the range of asset entries
621            * @param end the upper bound of the range of asset entries (not inclusive)
622            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
623            * @return the ordered range of matching asset entries
624            */
625            public static List<AssetEntry> findByPublishDate(Date publishDate,
626                    int start, int end, OrderByComparator<AssetEntry> orderByComparator) {
627                    return getPersistence()
628                                       .findByPublishDate(publishDate, start, end, orderByComparator);
629            }
630    
631            /**
632            * Returns an ordered range of all the asset entries where publishDate = &#63;.
633            *
634            * <p>
635            * 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.
636            * </p>
637            *
638            * @param publishDate the publish date
639            * @param start the lower bound of the range of asset entries
640            * @param end the upper bound of the range of asset entries (not inclusive)
641            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
642            * @param retrieveFromCache whether to retrieve from the finder cache
643            * @return the ordered range of matching asset entries
644            */
645            public static List<AssetEntry> findByPublishDate(Date publishDate,
646                    int start, int end, OrderByComparator<AssetEntry> orderByComparator,
647                    boolean retrieveFromCache) {
648                    return getPersistence()
649                                       .findByPublishDate(publishDate, start, end,
650                            orderByComparator, retrieveFromCache);
651            }
652    
653            /**
654            * Returns the first asset entry in the ordered set where publishDate = &#63;.
655            *
656            * @param publishDate the publish date
657            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
658            * @return the first matching asset entry
659            * @throws NoSuchEntryException if a matching asset entry could not be found
660            */
661            public static AssetEntry findByPublishDate_First(Date publishDate,
662                    OrderByComparator<AssetEntry> orderByComparator)
663                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
664                    return getPersistence()
665                                       .findByPublishDate_First(publishDate, orderByComparator);
666            }
667    
668            /**
669            * Returns the first asset entry in the ordered set where publishDate = &#63;.
670            *
671            * @param publishDate the publish date
672            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
673            * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found
674            */
675            public static AssetEntry fetchByPublishDate_First(Date publishDate,
676                    OrderByComparator<AssetEntry> orderByComparator) {
677                    return getPersistence()
678                                       .fetchByPublishDate_First(publishDate, orderByComparator);
679            }
680    
681            /**
682            * Returns the last asset entry in the ordered set where publishDate = &#63;.
683            *
684            * @param publishDate the publish date
685            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
686            * @return the last matching asset entry
687            * @throws NoSuchEntryException if a matching asset entry could not be found
688            */
689            public static AssetEntry findByPublishDate_Last(Date publishDate,
690                    OrderByComparator<AssetEntry> orderByComparator)
691                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
692                    return getPersistence()
693                                       .findByPublishDate_Last(publishDate, orderByComparator);
694            }
695    
696            /**
697            * Returns the last asset entry in the ordered set where publishDate = &#63;.
698            *
699            * @param publishDate the publish date
700            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
701            * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found
702            */
703            public static AssetEntry fetchByPublishDate_Last(Date publishDate,
704                    OrderByComparator<AssetEntry> orderByComparator) {
705                    return getPersistence()
706                                       .fetchByPublishDate_Last(publishDate, orderByComparator);
707            }
708    
709            /**
710            * Returns the asset entries before and after the current asset entry in the ordered set where publishDate = &#63;.
711            *
712            * @param entryId the primary key of the current asset entry
713            * @param publishDate the publish date
714            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
715            * @return the previous, current, and next asset entry
716            * @throws NoSuchEntryException if a asset entry with the primary key could not be found
717            */
718            public static AssetEntry[] findByPublishDate_PrevAndNext(long entryId,
719                    Date publishDate, OrderByComparator<AssetEntry> orderByComparator)
720                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
721                    return getPersistence()
722                                       .findByPublishDate_PrevAndNext(entryId, publishDate,
723                            orderByComparator);
724            }
725    
726            /**
727            * Removes all the asset entries where publishDate = &#63; from the database.
728            *
729            * @param publishDate the publish date
730            */
731            public static void removeByPublishDate(Date publishDate) {
732                    getPersistence().removeByPublishDate(publishDate);
733            }
734    
735            /**
736            * Returns the number of asset entries where publishDate = &#63;.
737            *
738            * @param publishDate the publish date
739            * @return the number of matching asset entries
740            */
741            public static int countByPublishDate(Date publishDate) {
742                    return getPersistence().countByPublishDate(publishDate);
743            }
744    
745            /**
746            * Returns all the asset entries where expirationDate = &#63;.
747            *
748            * @param expirationDate the expiration date
749            * @return the matching asset entries
750            */
751            public static List<AssetEntry> findByExpirationDate(Date expirationDate) {
752                    return getPersistence().findByExpirationDate(expirationDate);
753            }
754    
755            /**
756            * Returns a range of all the asset entries where expirationDate = &#63;.
757            *
758            * <p>
759            * 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.
760            * </p>
761            *
762            * @param expirationDate the expiration date
763            * @param start the lower bound of the range of asset entries
764            * @param end the upper bound of the range of asset entries (not inclusive)
765            * @return the range of matching asset entries
766            */
767            public static List<AssetEntry> findByExpirationDate(Date expirationDate,
768                    int start, int end) {
769                    return getPersistence().findByExpirationDate(expirationDate, start, end);
770            }
771    
772            /**
773            * Returns an ordered range of all the asset entries where expirationDate = &#63;.
774            *
775            * <p>
776            * 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.
777            * </p>
778            *
779            * @param expirationDate the expiration date
780            * @param start the lower bound of the range of asset entries
781            * @param end the upper bound of the range of asset entries (not inclusive)
782            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
783            * @return the ordered range of matching asset entries
784            */
785            public static List<AssetEntry> findByExpirationDate(Date expirationDate,
786                    int start, int end, OrderByComparator<AssetEntry> orderByComparator) {
787                    return getPersistence()
788                                       .findByExpirationDate(expirationDate, start, end,
789                            orderByComparator);
790            }
791    
792            /**
793            * Returns an ordered range of all the asset entries where expirationDate = &#63;.
794            *
795            * <p>
796            * 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.
797            * </p>
798            *
799            * @param expirationDate the expiration date
800            * @param start the lower bound of the range of asset entries
801            * @param end the upper bound of the range of asset entries (not inclusive)
802            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
803            * @param retrieveFromCache whether to retrieve from the finder cache
804            * @return the ordered range of matching asset entries
805            */
806            public static List<AssetEntry> findByExpirationDate(Date expirationDate,
807                    int start, int end, OrderByComparator<AssetEntry> orderByComparator,
808                    boolean retrieveFromCache) {
809                    return getPersistence()
810                                       .findByExpirationDate(expirationDate, start, end,
811                            orderByComparator, retrieveFromCache);
812            }
813    
814            /**
815            * Returns the first asset entry in the ordered set where expirationDate = &#63;.
816            *
817            * @param expirationDate the expiration date
818            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
819            * @return the first matching asset entry
820            * @throws NoSuchEntryException if a matching asset entry could not be found
821            */
822            public static AssetEntry findByExpirationDate_First(Date expirationDate,
823                    OrderByComparator<AssetEntry> orderByComparator)
824                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
825                    return getPersistence()
826                                       .findByExpirationDate_First(expirationDate, orderByComparator);
827            }
828    
829            /**
830            * Returns the first asset entry in the ordered set where expirationDate = &#63;.
831            *
832            * @param expirationDate the expiration date
833            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
834            * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found
835            */
836            public static AssetEntry fetchByExpirationDate_First(Date expirationDate,
837                    OrderByComparator<AssetEntry> orderByComparator) {
838                    return getPersistence()
839                                       .fetchByExpirationDate_First(expirationDate,
840                            orderByComparator);
841            }
842    
843            /**
844            * Returns the last asset entry in the ordered set where expirationDate = &#63;.
845            *
846            * @param expirationDate the expiration date
847            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
848            * @return the last matching asset entry
849            * @throws NoSuchEntryException if a matching asset entry could not be found
850            */
851            public static AssetEntry findByExpirationDate_Last(Date expirationDate,
852                    OrderByComparator<AssetEntry> orderByComparator)
853                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
854                    return getPersistence()
855                                       .findByExpirationDate_Last(expirationDate, orderByComparator);
856            }
857    
858            /**
859            * Returns the last asset entry in the ordered set where expirationDate = &#63;.
860            *
861            * @param expirationDate the expiration date
862            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
863            * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found
864            */
865            public static AssetEntry fetchByExpirationDate_Last(Date expirationDate,
866                    OrderByComparator<AssetEntry> orderByComparator) {
867                    return getPersistence()
868                                       .fetchByExpirationDate_Last(expirationDate, orderByComparator);
869            }
870    
871            /**
872            * Returns the asset entries before and after the current asset entry in the ordered set where expirationDate = &#63;.
873            *
874            * @param entryId the primary key of the current asset entry
875            * @param expirationDate the expiration date
876            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
877            * @return the previous, current, and next asset entry
878            * @throws NoSuchEntryException if a asset entry with the primary key could not be found
879            */
880            public static AssetEntry[] findByExpirationDate_PrevAndNext(long entryId,
881                    Date expirationDate, OrderByComparator<AssetEntry> orderByComparator)
882                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
883                    return getPersistence()
884                                       .findByExpirationDate_PrevAndNext(entryId, expirationDate,
885                            orderByComparator);
886            }
887    
888            /**
889            * Removes all the asset entries where expirationDate = &#63; from the database.
890            *
891            * @param expirationDate the expiration date
892            */
893            public static void removeByExpirationDate(Date expirationDate) {
894                    getPersistence().removeByExpirationDate(expirationDate);
895            }
896    
897            /**
898            * Returns the number of asset entries where expirationDate = &#63;.
899            *
900            * @param expirationDate the expiration date
901            * @return the number of matching asset entries
902            */
903            public static int countByExpirationDate(Date expirationDate) {
904                    return getPersistence().countByExpirationDate(expirationDate);
905            }
906    
907            /**
908            * Returns all the asset entries where layoutUuid = &#63;.
909            *
910            * @param layoutUuid the layout uuid
911            * @return the matching asset entries
912            */
913            public static List<AssetEntry> findByLayoutUuid(java.lang.String layoutUuid) {
914                    return getPersistence().findByLayoutUuid(layoutUuid);
915            }
916    
917            /**
918            * Returns a range of all the asset entries where layoutUuid = &#63;.
919            *
920            * <p>
921            * 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.
922            * </p>
923            *
924            * @param layoutUuid the layout uuid
925            * @param start the lower bound of the range of asset entries
926            * @param end the upper bound of the range of asset entries (not inclusive)
927            * @return the range of matching asset entries
928            */
929            public static List<AssetEntry> findByLayoutUuid(
930                    java.lang.String layoutUuid, int start, int end) {
931                    return getPersistence().findByLayoutUuid(layoutUuid, start, end);
932            }
933    
934            /**
935            * Returns an ordered range of all the asset entries where layoutUuid = &#63;.
936            *
937            * <p>
938            * 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.
939            * </p>
940            *
941            * @param layoutUuid the layout uuid
942            * @param start the lower bound of the range of asset entries
943            * @param end the upper bound of the range of asset entries (not inclusive)
944            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
945            * @return the ordered range of matching asset entries
946            */
947            public static List<AssetEntry> findByLayoutUuid(
948                    java.lang.String layoutUuid, int start, int end,
949                    OrderByComparator<AssetEntry> orderByComparator) {
950                    return getPersistence()
951                                       .findByLayoutUuid(layoutUuid, start, end, orderByComparator);
952            }
953    
954            /**
955            * Returns an ordered range of all the asset entries where layoutUuid = &#63;.
956            *
957            * <p>
958            * 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.
959            * </p>
960            *
961            * @param layoutUuid the layout uuid
962            * @param start the lower bound of the range of asset entries
963            * @param end the upper bound of the range of asset entries (not inclusive)
964            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
965            * @param retrieveFromCache whether to retrieve from the finder cache
966            * @return the ordered range of matching asset entries
967            */
968            public static List<AssetEntry> findByLayoutUuid(
969                    java.lang.String layoutUuid, int start, int end,
970                    OrderByComparator<AssetEntry> orderByComparator,
971                    boolean retrieveFromCache) {
972                    return getPersistence()
973                                       .findByLayoutUuid(layoutUuid, start, end, orderByComparator,
974                            retrieveFromCache);
975            }
976    
977            /**
978            * Returns the first asset entry in the ordered set where layoutUuid = &#63;.
979            *
980            * @param layoutUuid the layout uuid
981            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
982            * @return the first matching asset entry
983            * @throws NoSuchEntryException if a matching asset entry could not be found
984            */
985            public static AssetEntry findByLayoutUuid_First(
986                    java.lang.String layoutUuid,
987                    OrderByComparator<AssetEntry> orderByComparator)
988                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
989                    return getPersistence()
990                                       .findByLayoutUuid_First(layoutUuid, orderByComparator);
991            }
992    
993            /**
994            * Returns the first asset entry in the ordered set where layoutUuid = &#63;.
995            *
996            * @param layoutUuid the layout uuid
997            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
998            * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found
999            */
1000            public static AssetEntry fetchByLayoutUuid_First(
1001                    java.lang.String layoutUuid,
1002                    OrderByComparator<AssetEntry> orderByComparator) {
1003                    return getPersistence()
1004                                       .fetchByLayoutUuid_First(layoutUuid, orderByComparator);
1005            }
1006    
1007            /**
1008            * Returns the last asset entry in the ordered set where layoutUuid = &#63;.
1009            *
1010            * @param layoutUuid the layout uuid
1011            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1012            * @return the last matching asset entry
1013            * @throws NoSuchEntryException if a matching asset entry could not be found
1014            */
1015            public static AssetEntry findByLayoutUuid_Last(
1016                    java.lang.String layoutUuid,
1017                    OrderByComparator<AssetEntry> orderByComparator)
1018                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
1019                    return getPersistence()
1020                                       .findByLayoutUuid_Last(layoutUuid, orderByComparator);
1021            }
1022    
1023            /**
1024            * Returns the last asset entry in the ordered set where layoutUuid = &#63;.
1025            *
1026            * @param layoutUuid the layout uuid
1027            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1028            * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found
1029            */
1030            public static AssetEntry fetchByLayoutUuid_Last(
1031                    java.lang.String layoutUuid,
1032                    OrderByComparator<AssetEntry> orderByComparator) {
1033                    return getPersistence()
1034                                       .fetchByLayoutUuid_Last(layoutUuid, orderByComparator);
1035            }
1036    
1037            /**
1038            * Returns the asset entries before and after the current asset entry in the ordered set where layoutUuid = &#63;.
1039            *
1040            * @param entryId the primary key of the current asset entry
1041            * @param layoutUuid the layout uuid
1042            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1043            * @return the previous, current, and next asset entry
1044            * @throws NoSuchEntryException if a asset entry with the primary key could not be found
1045            */
1046            public static AssetEntry[] findByLayoutUuid_PrevAndNext(long entryId,
1047                    java.lang.String layoutUuid,
1048                    OrderByComparator<AssetEntry> orderByComparator)
1049                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
1050                    return getPersistence()
1051                                       .findByLayoutUuid_PrevAndNext(entryId, layoutUuid,
1052                            orderByComparator);
1053            }
1054    
1055            /**
1056            * Removes all the asset entries where layoutUuid = &#63; from the database.
1057            *
1058            * @param layoutUuid the layout uuid
1059            */
1060            public static void removeByLayoutUuid(java.lang.String layoutUuid) {
1061                    getPersistence().removeByLayoutUuid(layoutUuid);
1062            }
1063    
1064            /**
1065            * Returns the number of asset entries where layoutUuid = &#63;.
1066            *
1067            * @param layoutUuid the layout uuid
1068            * @return the number of matching asset entries
1069            */
1070            public static int countByLayoutUuid(java.lang.String layoutUuid) {
1071                    return getPersistence().countByLayoutUuid(layoutUuid);
1072            }
1073    
1074            /**
1075            * Returns the asset entry where groupId = &#63; and classUuid = &#63; or throws a {@link NoSuchEntryException} if it could not be found.
1076            *
1077            * @param groupId the group ID
1078            * @param classUuid the class uuid
1079            * @return the matching asset entry
1080            * @throws NoSuchEntryException if a matching asset entry could not be found
1081            */
1082            public static AssetEntry findByG_CU(long groupId, java.lang.String classUuid)
1083                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
1084                    return getPersistence().findByG_CU(groupId, classUuid);
1085            }
1086    
1087            /**
1088            * 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.
1089            *
1090            * @param groupId the group ID
1091            * @param classUuid the class uuid
1092            * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found
1093            */
1094            public static AssetEntry fetchByG_CU(long groupId,
1095                    java.lang.String classUuid) {
1096                    return getPersistence().fetchByG_CU(groupId, classUuid);
1097            }
1098    
1099            /**
1100            * 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.
1101            *
1102            * @param groupId the group ID
1103            * @param classUuid the class uuid
1104            * @param retrieveFromCache whether to retrieve from the finder cache
1105            * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found
1106            */
1107            public static AssetEntry fetchByG_CU(long groupId,
1108                    java.lang.String classUuid, boolean retrieveFromCache) {
1109                    return getPersistence()
1110                                       .fetchByG_CU(groupId, classUuid, retrieveFromCache);
1111            }
1112    
1113            /**
1114            * Removes the asset entry where groupId = &#63; and classUuid = &#63; from the database.
1115            *
1116            * @param groupId the group ID
1117            * @param classUuid the class uuid
1118            * @return the asset entry that was removed
1119            */
1120            public static AssetEntry removeByG_CU(long groupId,
1121                    java.lang.String classUuid)
1122                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
1123                    return getPersistence().removeByG_CU(groupId, classUuid);
1124            }
1125    
1126            /**
1127            * Returns the number of asset entries where groupId = &#63; and classUuid = &#63;.
1128            *
1129            * @param groupId the group ID
1130            * @param classUuid the class uuid
1131            * @return the number of matching asset entries
1132            */
1133            public static int countByG_CU(long groupId, java.lang.String classUuid) {
1134                    return getPersistence().countByG_CU(groupId, classUuid);
1135            }
1136    
1137            /**
1138            * Returns the asset entry where classNameId = &#63; and classPK = &#63; or throws a {@link NoSuchEntryException} if it could not be found.
1139            *
1140            * @param classNameId the class name ID
1141            * @param classPK the class p k
1142            * @return the matching asset entry
1143            * @throws NoSuchEntryException if a matching asset entry could not be found
1144            */
1145            public static AssetEntry findByC_C(long classNameId, long classPK)
1146                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
1147                    return getPersistence().findByC_C(classNameId, classPK);
1148            }
1149    
1150            /**
1151            * 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.
1152            *
1153            * @param classNameId the class name ID
1154            * @param classPK the class p k
1155            * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found
1156            */
1157            public static AssetEntry fetchByC_C(long classNameId, long classPK) {
1158                    return getPersistence().fetchByC_C(classNameId, classPK);
1159            }
1160    
1161            /**
1162            * 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.
1163            *
1164            * @param classNameId the class name ID
1165            * @param classPK the class p k
1166            * @param retrieveFromCache whether to retrieve from the finder cache
1167            * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found
1168            */
1169            public static AssetEntry fetchByC_C(long classNameId, long classPK,
1170                    boolean retrieveFromCache) {
1171                    return getPersistence()
1172                                       .fetchByC_C(classNameId, classPK, retrieveFromCache);
1173            }
1174    
1175            /**
1176            * Removes the asset entry where classNameId = &#63; and classPK = &#63; from the database.
1177            *
1178            * @param classNameId the class name ID
1179            * @param classPK the class p k
1180            * @return the asset entry that was removed
1181            */
1182            public static AssetEntry removeByC_C(long classNameId, long classPK)
1183                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
1184                    return getPersistence().removeByC_C(classNameId, classPK);
1185            }
1186    
1187            /**
1188            * Returns the number of asset entries where classNameId = &#63; and classPK = &#63;.
1189            *
1190            * @param classNameId the class name ID
1191            * @param classPK the class p k
1192            * @return the number of matching asset entries
1193            */
1194            public static int countByC_C(long classNameId, long classPK) {
1195                    return getPersistence().countByC_C(classNameId, classPK);
1196            }
1197    
1198            /**
1199            * Caches the asset entry in the entity cache if it is enabled.
1200            *
1201            * @param assetEntry the asset entry
1202            */
1203            public static void cacheResult(AssetEntry assetEntry) {
1204                    getPersistence().cacheResult(assetEntry);
1205            }
1206    
1207            /**
1208            * Caches the asset entries in the entity cache if it is enabled.
1209            *
1210            * @param assetEntries the asset entries
1211            */
1212            public static void cacheResult(List<AssetEntry> assetEntries) {
1213                    getPersistence().cacheResult(assetEntries);
1214            }
1215    
1216            /**
1217            * Creates a new asset entry with the primary key. Does not add the asset entry to the database.
1218            *
1219            * @param entryId the primary key for the new asset entry
1220            * @return the new asset entry
1221            */
1222            public static AssetEntry create(long entryId) {
1223                    return getPersistence().create(entryId);
1224            }
1225    
1226            /**
1227            * Removes the asset entry with the primary key from the database. Also notifies the appropriate model listeners.
1228            *
1229            * @param entryId the primary key of the asset entry
1230            * @return the asset entry that was removed
1231            * @throws NoSuchEntryException if a asset entry with the primary key could not be found
1232            */
1233            public static AssetEntry remove(long entryId)
1234                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
1235                    return getPersistence().remove(entryId);
1236            }
1237    
1238            public static AssetEntry updateImpl(AssetEntry assetEntry) {
1239                    return getPersistence().updateImpl(assetEntry);
1240            }
1241    
1242            /**
1243            * Returns the asset entry with the primary key or throws a {@link NoSuchEntryException} if it could not be found.
1244            *
1245            * @param entryId the primary key of the asset entry
1246            * @return the asset entry
1247            * @throws NoSuchEntryException if a asset entry with the primary key could not be found
1248            */
1249            public static AssetEntry findByPrimaryKey(long entryId)
1250                    throws com.liferay.portlet.asset.exception.NoSuchEntryException {
1251                    return getPersistence().findByPrimaryKey(entryId);
1252            }
1253    
1254            /**
1255            * Returns the asset entry with the primary key or returns <code>null</code> if it could not be found.
1256            *
1257            * @param entryId the primary key of the asset entry
1258            * @return the asset entry, or <code>null</code> if a asset entry with the primary key could not be found
1259            */
1260            public static AssetEntry fetchByPrimaryKey(long entryId) {
1261                    return getPersistence().fetchByPrimaryKey(entryId);
1262            }
1263    
1264            public static java.util.Map<java.io.Serializable, AssetEntry> fetchByPrimaryKeys(
1265                    java.util.Set<java.io.Serializable> primaryKeys) {
1266                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1267            }
1268    
1269            /**
1270            * Returns all the asset entries.
1271            *
1272            * @return the asset entries
1273            */
1274            public static List<AssetEntry> findAll() {
1275                    return getPersistence().findAll();
1276            }
1277    
1278            /**
1279            * Returns a range of all the asset entries.
1280            *
1281            * <p>
1282            * 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.
1283            * </p>
1284            *
1285            * @param start the lower bound of the range of asset entries
1286            * @param end the upper bound of the range of asset entries (not inclusive)
1287            * @return the range of asset entries
1288            */
1289            public static List<AssetEntry> findAll(int start, int end) {
1290                    return getPersistence().findAll(start, end);
1291            }
1292    
1293            /**
1294            * Returns an ordered range of all the asset entries.
1295            *
1296            * <p>
1297            * 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.
1298            * </p>
1299            *
1300            * @param start the lower bound of the range of asset entries
1301            * @param end the upper bound of the range of asset entries (not inclusive)
1302            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1303            * @return the ordered range of asset entries
1304            */
1305            public static List<AssetEntry> findAll(int start, int end,
1306                    OrderByComparator<AssetEntry> orderByComparator) {
1307                    return getPersistence().findAll(start, end, orderByComparator);
1308            }
1309    
1310            /**
1311            * Returns an ordered range of all the asset entries.
1312            *
1313            * <p>
1314            * 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.
1315            * </p>
1316            *
1317            * @param start the lower bound of the range of asset entries
1318            * @param end the upper bound of the range of asset entries (not inclusive)
1319            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1320            * @param retrieveFromCache whether to retrieve from the finder cache
1321            * @return the ordered range of asset entries
1322            */
1323            public static List<AssetEntry> findAll(int start, int end,
1324                    OrderByComparator<AssetEntry> orderByComparator,
1325                    boolean retrieveFromCache) {
1326                    return getPersistence()
1327                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1328            }
1329    
1330            /**
1331            * Removes all the asset entries from the database.
1332            */
1333            public static void removeAll() {
1334                    getPersistence().removeAll();
1335            }
1336    
1337            /**
1338            * Returns the number of asset entries.
1339            *
1340            * @return the number of asset entries
1341            */
1342            public static int countAll() {
1343                    return getPersistence().countAll();
1344            }
1345    
1346            /**
1347            * Returns the primaryKeys of asset categories associated with the asset entry.
1348            *
1349            * @param pk the primary key of the asset entry
1350            * @return long[] of the primaryKeys of asset categories associated with the asset entry
1351            */
1352            public static long[] getAssetCategoryPrimaryKeys(long pk) {
1353                    return getPersistence().getAssetCategoryPrimaryKeys(pk);
1354            }
1355    
1356            /**
1357            * Returns all the asset categories associated with the asset entry.
1358            *
1359            * @param pk the primary key of the asset entry
1360            * @return the asset categories associated with the asset entry
1361            */
1362            public static List<com.liferay.portlet.asset.model.AssetCategory> getAssetCategories(
1363                    long pk) {
1364                    return getPersistence().getAssetCategories(pk);
1365            }
1366    
1367            /**
1368            * Returns a range of all the asset categories associated with the asset entry.
1369            *
1370            * <p>
1371            * 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.
1372            * </p>
1373            *
1374            * @param pk the primary key of the asset entry
1375            * @param start the lower bound of the range of asset entries
1376            * @param end the upper bound of the range of asset entries (not inclusive)
1377            * @return the range of asset categories associated with the asset entry
1378            */
1379            public static List<com.liferay.portlet.asset.model.AssetCategory> getAssetCategories(
1380                    long pk, int start, int end) {
1381                    return getPersistence().getAssetCategories(pk, start, end);
1382            }
1383    
1384            /**
1385            * Returns an ordered range of all the asset categories associated with the asset entry.
1386            *
1387            * <p>
1388            * 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.
1389            * </p>
1390            *
1391            * @param pk the primary key of the asset entry
1392            * @param start the lower bound of the range of asset entries
1393            * @param end the upper bound of the range of asset entries (not inclusive)
1394            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1395            * @return the ordered range of asset categories associated with the asset entry
1396            */
1397            public static List<com.liferay.portlet.asset.model.AssetCategory> getAssetCategories(
1398                    long pk, int start, int end,
1399                    OrderByComparator<com.liferay.portlet.asset.model.AssetCategory> orderByComparator) {
1400                    return getPersistence()
1401                                       .getAssetCategories(pk, start, end, orderByComparator);
1402            }
1403    
1404            /**
1405            * Returns the number of asset categories associated with the asset entry.
1406            *
1407            * @param pk the primary key of the asset entry
1408            * @return the number of asset categories associated with the asset entry
1409            */
1410            public static int getAssetCategoriesSize(long pk) {
1411                    return getPersistence().getAssetCategoriesSize(pk);
1412            }
1413    
1414            /**
1415            * Returns <code>true</code> if the asset category is associated with the asset entry.
1416            *
1417            * @param pk the primary key of the asset entry
1418            * @param assetCategoryPK the primary key of the asset category
1419            * @return <code>true</code> if the asset category is associated with the asset entry; <code>false</code> otherwise
1420            */
1421            public static boolean containsAssetCategory(long pk, long assetCategoryPK) {
1422                    return getPersistence().containsAssetCategory(pk, assetCategoryPK);
1423            }
1424    
1425            /**
1426            * Returns <code>true</code> if the asset entry has any asset categories associated with it.
1427            *
1428            * @param pk the primary key of the asset entry to check for associations with asset categories
1429            * @return <code>true</code> if the asset entry has any asset categories associated with it; <code>false</code> otherwise
1430            */
1431            public static boolean containsAssetCategories(long pk) {
1432                    return getPersistence().containsAssetCategories(pk);
1433            }
1434    
1435            /**
1436            * Adds an association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1437            *
1438            * @param pk the primary key of the asset entry
1439            * @param assetCategoryPK the primary key of the asset category
1440            */
1441            public static void addAssetCategory(long pk, long assetCategoryPK) {
1442                    getPersistence().addAssetCategory(pk, assetCategoryPK);
1443            }
1444    
1445            /**
1446            * Adds an association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1447            *
1448            * @param pk the primary key of the asset entry
1449            * @param assetCategory the asset category
1450            */
1451            public static void addAssetCategory(long pk,
1452                    com.liferay.portlet.asset.model.AssetCategory assetCategory) {
1453                    getPersistence().addAssetCategory(pk, assetCategory);
1454            }
1455    
1456            /**
1457            * Adds an association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1458            *
1459            * @param pk the primary key of the asset entry
1460            * @param assetCategoryPKs the primary keys of the asset categories
1461            */
1462            public static void addAssetCategories(long pk, long[] assetCategoryPKs) {
1463                    getPersistence().addAssetCategories(pk, assetCategoryPKs);
1464            }
1465    
1466            /**
1467            * Adds an association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1468            *
1469            * @param pk the primary key of the asset entry
1470            * @param assetCategories the asset categories
1471            */
1472            public static void addAssetCategories(long pk,
1473                    List<com.liferay.portlet.asset.model.AssetCategory> assetCategories) {
1474                    getPersistence().addAssetCategories(pk, assetCategories);
1475            }
1476    
1477            /**
1478            * Clears all associations between the asset entry and its asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1479            *
1480            * @param pk the primary key of the asset entry to clear the associated asset categories from
1481            */
1482            public static void clearAssetCategories(long pk) {
1483                    getPersistence().clearAssetCategories(pk);
1484            }
1485    
1486            /**
1487            * Removes the association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1488            *
1489            * @param pk the primary key of the asset entry
1490            * @param assetCategoryPK the primary key of the asset category
1491            */
1492            public static void removeAssetCategory(long pk, long assetCategoryPK) {
1493                    getPersistence().removeAssetCategory(pk, assetCategoryPK);
1494            }
1495    
1496            /**
1497            * Removes the association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1498            *
1499            * @param pk the primary key of the asset entry
1500            * @param assetCategory the asset category
1501            */
1502            public static void removeAssetCategory(long pk,
1503                    com.liferay.portlet.asset.model.AssetCategory assetCategory) {
1504                    getPersistence().removeAssetCategory(pk, assetCategory);
1505            }
1506    
1507            /**
1508            * Removes the association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1509            *
1510            * @param pk the primary key of the asset entry
1511            * @param assetCategoryPKs the primary keys of the asset categories
1512            */
1513            public static void removeAssetCategories(long pk, long[] assetCategoryPKs) {
1514                    getPersistence().removeAssetCategories(pk, assetCategoryPKs);
1515            }
1516    
1517            /**
1518            * Removes the association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1519            *
1520            * @param pk the primary key of the asset entry
1521            * @param assetCategories the asset categories
1522            */
1523            public static void removeAssetCategories(long pk,
1524                    List<com.liferay.portlet.asset.model.AssetCategory> assetCategories) {
1525                    getPersistence().removeAssetCategories(pk, assetCategories);
1526            }
1527    
1528            /**
1529            * 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.
1530            *
1531            * @param pk the primary key of the asset entry
1532            * @param assetCategoryPKs the primary keys of the asset categories to be associated with the asset entry
1533            */
1534            public static void setAssetCategories(long pk, long[] assetCategoryPKs) {
1535                    getPersistence().setAssetCategories(pk, assetCategoryPKs);
1536            }
1537    
1538            /**
1539            * 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.
1540            *
1541            * @param pk the primary key of the asset entry
1542            * @param assetCategories the asset categories to be associated with the asset entry
1543            */
1544            public static void setAssetCategories(long pk,
1545                    List<com.liferay.portlet.asset.model.AssetCategory> assetCategories) {
1546                    getPersistence().setAssetCategories(pk, assetCategories);
1547            }
1548    
1549            /**
1550            * Returns the primaryKeys of asset tags associated with the asset entry.
1551            *
1552            * @param pk the primary key of the asset entry
1553            * @return long[] of the primaryKeys of asset tags associated with the asset entry
1554            */
1555            public static long[] getAssetTagPrimaryKeys(long pk) {
1556                    return getPersistence().getAssetTagPrimaryKeys(pk);
1557            }
1558    
1559            /**
1560            * Returns all the asset tags associated with the asset entry.
1561            *
1562            * @param pk the primary key of the asset entry
1563            * @return the asset tags associated with the asset entry
1564            */
1565            public static List<com.liferay.portlet.asset.model.AssetTag> getAssetTags(
1566                    long pk) {
1567                    return getPersistence().getAssetTags(pk);
1568            }
1569    
1570            /**
1571            * Returns a range of all the asset tags associated with the asset entry.
1572            *
1573            * <p>
1574            * 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.
1575            * </p>
1576            *
1577            * @param pk the primary key of the asset entry
1578            * @param start the lower bound of the range of asset entries
1579            * @param end the upper bound of the range of asset entries (not inclusive)
1580            * @return the range of asset tags associated with the asset entry
1581            */
1582            public static List<com.liferay.portlet.asset.model.AssetTag> getAssetTags(
1583                    long pk, int start, int end) {
1584                    return getPersistence().getAssetTags(pk, start, end);
1585            }
1586    
1587            /**
1588            * Returns an ordered range of all the asset tags associated with the asset entry.
1589            *
1590            * <p>
1591            * 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.
1592            * </p>
1593            *
1594            * @param pk the primary key of the asset entry
1595            * @param start the lower bound of the range of asset entries
1596            * @param end the upper bound of the range of asset entries (not inclusive)
1597            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1598            * @return the ordered range of asset tags associated with the asset entry
1599            */
1600            public static List<com.liferay.portlet.asset.model.AssetTag> getAssetTags(
1601                    long pk, int start, int end,
1602                    OrderByComparator<com.liferay.portlet.asset.model.AssetTag> orderByComparator) {
1603                    return getPersistence().getAssetTags(pk, start, end, orderByComparator);
1604            }
1605    
1606            /**
1607            * Returns the number of asset tags associated with the asset entry.
1608            *
1609            * @param pk the primary key of the asset entry
1610            * @return the number of asset tags associated with the asset entry
1611            */
1612            public static int getAssetTagsSize(long pk) {
1613                    return getPersistence().getAssetTagsSize(pk);
1614            }
1615    
1616            /**
1617            * Returns <code>true</code> if the asset tag is associated with the asset entry.
1618            *
1619            * @param pk the primary key of the asset entry
1620            * @param assetTagPK the primary key of the asset tag
1621            * @return <code>true</code> if the asset tag is associated with the asset entry; <code>false</code> otherwise
1622            */
1623            public static boolean containsAssetTag(long pk, long assetTagPK) {
1624                    return getPersistence().containsAssetTag(pk, assetTagPK);
1625            }
1626    
1627            /**
1628            * Returns <code>true</code> if the asset entry has any asset tags associated with it.
1629            *
1630            * @param pk the primary key of the asset entry to check for associations with asset tags
1631            * @return <code>true</code> if the asset entry has any asset tags associated with it; <code>false</code> otherwise
1632            */
1633            public static boolean containsAssetTags(long pk) {
1634                    return getPersistence().containsAssetTags(pk);
1635            }
1636    
1637            /**
1638            * Adds an association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1639            *
1640            * @param pk the primary key of the asset entry
1641            * @param assetTagPK the primary key of the asset tag
1642            */
1643            public static void addAssetTag(long pk, long assetTagPK) {
1644                    getPersistence().addAssetTag(pk, assetTagPK);
1645            }
1646    
1647            /**
1648            * Adds an association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1649            *
1650            * @param pk the primary key of the asset entry
1651            * @param assetTag the asset tag
1652            */
1653            public static void addAssetTag(long pk,
1654                    com.liferay.portlet.asset.model.AssetTag assetTag) {
1655                    getPersistence().addAssetTag(pk, assetTag);
1656            }
1657    
1658            /**
1659            * Adds an association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1660            *
1661            * @param pk the primary key of the asset entry
1662            * @param assetTagPKs the primary keys of the asset tags
1663            */
1664            public static void addAssetTags(long pk, long[] assetTagPKs) {
1665                    getPersistence().addAssetTags(pk, assetTagPKs);
1666            }
1667    
1668            /**
1669            * Adds an association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1670            *
1671            * @param pk the primary key of the asset entry
1672            * @param assetTags the asset tags
1673            */
1674            public static void addAssetTags(long pk,
1675                    List<com.liferay.portlet.asset.model.AssetTag> assetTags) {
1676                    getPersistence().addAssetTags(pk, assetTags);
1677            }
1678    
1679            /**
1680            * Clears all associations between the asset entry and its asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1681            *
1682            * @param pk the primary key of the asset entry to clear the associated asset tags from
1683            */
1684            public static void clearAssetTags(long pk) {
1685                    getPersistence().clearAssetTags(pk);
1686            }
1687    
1688            /**
1689            * Removes the association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1690            *
1691            * @param pk the primary key of the asset entry
1692            * @param assetTagPK the primary key of the asset tag
1693            */
1694            public static void removeAssetTag(long pk, long assetTagPK) {
1695                    getPersistence().removeAssetTag(pk, assetTagPK);
1696            }
1697    
1698            /**
1699            * Removes the association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1700            *
1701            * @param pk the primary key of the asset entry
1702            * @param assetTag the asset tag
1703            */
1704            public static void removeAssetTag(long pk,
1705                    com.liferay.portlet.asset.model.AssetTag assetTag) {
1706                    getPersistence().removeAssetTag(pk, assetTag);
1707            }
1708    
1709            /**
1710            * Removes the association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1711            *
1712            * @param pk the primary key of the asset entry
1713            * @param assetTagPKs the primary keys of the asset tags
1714            */
1715            public static void removeAssetTags(long pk, long[] assetTagPKs) {
1716                    getPersistence().removeAssetTags(pk, assetTagPKs);
1717            }
1718    
1719            /**
1720            * Removes the association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1721            *
1722            * @param pk the primary key of the asset entry
1723            * @param assetTags the asset tags
1724            */
1725            public static void removeAssetTags(long pk,
1726                    List<com.liferay.portlet.asset.model.AssetTag> assetTags) {
1727                    getPersistence().removeAssetTags(pk, assetTags);
1728            }
1729    
1730            /**
1731            * 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.
1732            *
1733            * @param pk the primary key of the asset entry
1734            * @param assetTagPKs the primary keys of the asset tags to be associated with the asset entry
1735            */
1736            public static void setAssetTags(long pk, long[] assetTagPKs) {
1737                    getPersistence().setAssetTags(pk, assetTagPKs);
1738            }
1739    
1740            /**
1741            * 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.
1742            *
1743            * @param pk the primary key of the asset entry
1744            * @param assetTags the asset tags to be associated with the asset entry
1745            */
1746            public static void setAssetTags(long pk,
1747                    List<com.liferay.portlet.asset.model.AssetTag> assetTags) {
1748                    getPersistence().setAssetTags(pk, assetTags);
1749            }
1750    
1751            public static AssetEntryPersistence getPersistence() {
1752                    if (_persistence == null) {
1753                            _persistence = (AssetEntryPersistence)PortalBeanLocatorUtil.locate(AssetEntryPersistence.class.getName());
1754    
1755                            ReferenceRegistry.registerReference(AssetEntryUtil.class,
1756                                    "_persistence");
1757                    }
1758    
1759                    return _persistence;
1760            }
1761    
1762            private static AssetEntryPersistence _persistence;
1763    }