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