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