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.portal.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.model.RepositoryEntry;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the repository entry service. This utility wraps {@link com.liferay.portal.service.persistence.impl.RepositoryEntryPersistenceImpl} 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.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see RepositoryEntryPersistence
037     * @see com.liferay.portal.service.persistence.impl.RepositoryEntryPersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class RepositoryEntryUtil {
042            /*
043             * NOTE FOR DEVELOPERS:
044             *
045             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
046             */
047    
048            /**
049             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
050             */
051            public static void clearCache() {
052                    getPersistence().clearCache();
053            }
054    
055            /**
056             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
057             */
058            public static void clearCache(RepositoryEntry repositoryEntry) {
059                    getPersistence().clearCache(repositoryEntry);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
064             */
065            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<RepositoryEntry> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<RepositoryEntry> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end) {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<RepositoryEntry> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<RepositoryEntry> orderByComparator) {
091                    return getPersistence()
092                                       .findWithDynamicQuery(dynamicQuery, start, end,
093                            orderByComparator);
094            }
095    
096            /**
097             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
098             */
099            public static RepositoryEntry update(RepositoryEntry repositoryEntry) {
100                    return getPersistence().update(repositoryEntry);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
105             */
106            public static RepositoryEntry update(RepositoryEntry repositoryEntry,
107                    ServiceContext serviceContext) {
108                    return getPersistence().update(repositoryEntry, serviceContext);
109            }
110    
111            /**
112            * Returns all the repository entries where uuid = &#63;.
113            *
114            * @param uuid the uuid
115            * @return the matching repository entries
116            */
117            public static List<RepositoryEntry> findByUuid(java.lang.String uuid) {
118                    return getPersistence().findByUuid(uuid);
119            }
120    
121            /**
122            * Returns a range of all the repository entries where uuid = &#63;.
123            *
124            * <p>
125            * 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 RepositoryEntryModelImpl}. 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.
126            * </p>
127            *
128            * @param uuid the uuid
129            * @param start the lower bound of the range of repository entries
130            * @param end the upper bound of the range of repository entries (not inclusive)
131            * @return the range of matching repository entries
132            */
133            public static List<RepositoryEntry> findByUuid(java.lang.String uuid,
134                    int start, int end) {
135                    return getPersistence().findByUuid(uuid, start, end);
136            }
137    
138            /**
139            * Returns an ordered range of all the repository entries where uuid = &#63;.
140            *
141            * <p>
142            * 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 RepositoryEntryModelImpl}. 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.
143            * </p>
144            *
145            * @param uuid the uuid
146            * @param start the lower bound of the range of repository entries
147            * @param end the upper bound of the range of repository entries (not inclusive)
148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
149            * @return the ordered range of matching repository entries
150            */
151            public static List<RepositoryEntry> findByUuid(java.lang.String uuid,
152                    int start, int end, OrderByComparator<RepositoryEntry> orderByComparator) {
153                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
154            }
155    
156            /**
157            * Returns the first repository entry in the ordered set where uuid = &#63;.
158            *
159            * @param uuid the uuid
160            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
161            * @return the first matching repository entry
162            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
163            */
164            public static RepositoryEntry findByUuid_First(java.lang.String uuid,
165                    OrderByComparator<RepositoryEntry> orderByComparator)
166                    throws com.liferay.portal.NoSuchRepositoryEntryException {
167                    return getPersistence().findByUuid_First(uuid, orderByComparator);
168            }
169    
170            /**
171            * Returns the first repository entry in the ordered set where uuid = &#63;.
172            *
173            * @param uuid the uuid
174            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
175            * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found
176            */
177            public static RepositoryEntry fetchByUuid_First(java.lang.String uuid,
178                    OrderByComparator<RepositoryEntry> orderByComparator) {
179                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
180            }
181    
182            /**
183            * Returns the last repository entry in the ordered set where uuid = &#63;.
184            *
185            * @param uuid the uuid
186            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
187            * @return the last matching repository entry
188            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
189            */
190            public static RepositoryEntry findByUuid_Last(java.lang.String uuid,
191                    OrderByComparator<RepositoryEntry> orderByComparator)
192                    throws com.liferay.portal.NoSuchRepositoryEntryException {
193                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
194            }
195    
196            /**
197            * Returns the last repository entry in the ordered set where uuid = &#63;.
198            *
199            * @param uuid the uuid
200            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
201            * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found
202            */
203            public static RepositoryEntry fetchByUuid_Last(java.lang.String uuid,
204                    OrderByComparator<RepositoryEntry> orderByComparator) {
205                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
206            }
207    
208            /**
209            * Returns the repository entries before and after the current repository entry in the ordered set where uuid = &#63;.
210            *
211            * @param repositoryEntryId the primary key of the current repository entry
212            * @param uuid the uuid
213            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
214            * @return the previous, current, and next repository entry
215            * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found
216            */
217            public static RepositoryEntry[] findByUuid_PrevAndNext(
218                    long repositoryEntryId, java.lang.String uuid,
219                    OrderByComparator<RepositoryEntry> orderByComparator)
220                    throws com.liferay.portal.NoSuchRepositoryEntryException {
221                    return getPersistence()
222                                       .findByUuid_PrevAndNext(repositoryEntryId, uuid,
223                            orderByComparator);
224            }
225    
226            /**
227            * Removes all the repository entries where uuid = &#63; from the database.
228            *
229            * @param uuid the uuid
230            */
231            public static void removeByUuid(java.lang.String uuid) {
232                    getPersistence().removeByUuid(uuid);
233            }
234    
235            /**
236            * Returns the number of repository entries where uuid = &#63;.
237            *
238            * @param uuid the uuid
239            * @return the number of matching repository entries
240            */
241            public static int countByUuid(java.lang.String uuid) {
242                    return getPersistence().countByUuid(uuid);
243            }
244    
245            /**
246            * Returns the repository entry where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchRepositoryEntryException} if it could not be found.
247            *
248            * @param uuid the uuid
249            * @param groupId the group ID
250            * @return the matching repository entry
251            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
252            */
253            public static RepositoryEntry findByUUID_G(java.lang.String uuid,
254                    long groupId) throws com.liferay.portal.NoSuchRepositoryEntryException {
255                    return getPersistence().findByUUID_G(uuid, groupId);
256            }
257    
258            /**
259            * Returns the repository entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
260            *
261            * @param uuid the uuid
262            * @param groupId the group ID
263            * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found
264            */
265            public static RepositoryEntry fetchByUUID_G(java.lang.String uuid,
266                    long groupId) {
267                    return getPersistence().fetchByUUID_G(uuid, groupId);
268            }
269    
270            /**
271            * Returns the repository entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
272            *
273            * @param uuid the uuid
274            * @param groupId the group ID
275            * @param retrieveFromCache whether to use the finder cache
276            * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found
277            */
278            public static RepositoryEntry fetchByUUID_G(java.lang.String uuid,
279                    long groupId, boolean retrieveFromCache) {
280                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
281            }
282    
283            /**
284            * Removes the repository entry where uuid = &#63; and groupId = &#63; from the database.
285            *
286            * @param uuid the uuid
287            * @param groupId the group ID
288            * @return the repository entry that was removed
289            */
290            public static RepositoryEntry removeByUUID_G(java.lang.String uuid,
291                    long groupId) throws com.liferay.portal.NoSuchRepositoryEntryException {
292                    return getPersistence().removeByUUID_G(uuid, groupId);
293            }
294    
295            /**
296            * Returns the number of repository entries where uuid = &#63; and groupId = &#63;.
297            *
298            * @param uuid the uuid
299            * @param groupId the group ID
300            * @return the number of matching repository entries
301            */
302            public static int countByUUID_G(java.lang.String uuid, long groupId) {
303                    return getPersistence().countByUUID_G(uuid, groupId);
304            }
305    
306            /**
307            * Returns all the repository entries where uuid = &#63; and companyId = &#63;.
308            *
309            * @param uuid the uuid
310            * @param companyId the company ID
311            * @return the matching repository entries
312            */
313            public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid,
314                    long companyId) {
315                    return getPersistence().findByUuid_C(uuid, companyId);
316            }
317    
318            /**
319            * Returns a range of all the repository entries where uuid = &#63; and companyId = &#63;.
320            *
321            * <p>
322            * 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 RepositoryEntryModelImpl}. 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.
323            * </p>
324            *
325            * @param uuid the uuid
326            * @param companyId the company ID
327            * @param start the lower bound of the range of repository entries
328            * @param end the upper bound of the range of repository entries (not inclusive)
329            * @return the range of matching repository entries
330            */
331            public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid,
332                    long companyId, int start, int end) {
333                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
334            }
335    
336            /**
337            * Returns an ordered range of all the repository entries where uuid = &#63; and companyId = &#63;.
338            *
339            * <p>
340            * 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 RepositoryEntryModelImpl}. 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.
341            * </p>
342            *
343            * @param uuid the uuid
344            * @param companyId the company ID
345            * @param start the lower bound of the range of repository entries
346            * @param end the upper bound of the range of repository entries (not inclusive)
347            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
348            * @return the ordered range of matching repository entries
349            */
350            public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid,
351                    long companyId, int start, int end,
352                    OrderByComparator<RepositoryEntry> orderByComparator) {
353                    return getPersistence()
354                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
355            }
356    
357            /**
358            * Returns the first repository entry in the ordered set where uuid = &#63; and companyId = &#63;.
359            *
360            * @param uuid the uuid
361            * @param companyId the company ID
362            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
363            * @return the first matching repository entry
364            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
365            */
366            public static RepositoryEntry findByUuid_C_First(java.lang.String uuid,
367                    long companyId, OrderByComparator<RepositoryEntry> orderByComparator)
368                    throws com.liferay.portal.NoSuchRepositoryEntryException {
369                    return getPersistence()
370                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
371            }
372    
373            /**
374            * Returns the first repository entry in the ordered set where uuid = &#63; and companyId = &#63;.
375            *
376            * @param uuid the uuid
377            * @param companyId the company ID
378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
379            * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found
380            */
381            public static RepositoryEntry fetchByUuid_C_First(java.lang.String uuid,
382                    long companyId, OrderByComparator<RepositoryEntry> orderByComparator) {
383                    return getPersistence()
384                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
385            }
386    
387            /**
388            * Returns the last repository entry in the ordered set where uuid = &#63; and companyId = &#63;.
389            *
390            * @param uuid the uuid
391            * @param companyId the company ID
392            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
393            * @return the last matching repository entry
394            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
395            */
396            public static RepositoryEntry findByUuid_C_Last(java.lang.String uuid,
397                    long companyId, OrderByComparator<RepositoryEntry> orderByComparator)
398                    throws com.liferay.portal.NoSuchRepositoryEntryException {
399                    return getPersistence()
400                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
401            }
402    
403            /**
404            * Returns the last repository entry in the ordered set where uuid = &#63; and companyId = &#63;.
405            *
406            * @param uuid the uuid
407            * @param companyId the company ID
408            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
409            * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found
410            */
411            public static RepositoryEntry fetchByUuid_C_Last(java.lang.String uuid,
412                    long companyId, OrderByComparator<RepositoryEntry> orderByComparator) {
413                    return getPersistence()
414                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
415            }
416    
417            /**
418            * Returns the repository entries before and after the current repository entry in the ordered set where uuid = &#63; and companyId = &#63;.
419            *
420            * @param repositoryEntryId the primary key of the current repository entry
421            * @param uuid the uuid
422            * @param companyId the company ID
423            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
424            * @return the previous, current, and next repository entry
425            * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found
426            */
427            public static RepositoryEntry[] findByUuid_C_PrevAndNext(
428                    long repositoryEntryId, java.lang.String uuid, long companyId,
429                    OrderByComparator<RepositoryEntry> orderByComparator)
430                    throws com.liferay.portal.NoSuchRepositoryEntryException {
431                    return getPersistence()
432                                       .findByUuid_C_PrevAndNext(repositoryEntryId, uuid,
433                            companyId, orderByComparator);
434            }
435    
436            /**
437            * Removes all the repository entries where uuid = &#63; and companyId = &#63; from the database.
438            *
439            * @param uuid the uuid
440            * @param companyId the company ID
441            */
442            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
443                    getPersistence().removeByUuid_C(uuid, companyId);
444            }
445    
446            /**
447            * Returns the number of repository entries where uuid = &#63; and companyId = &#63;.
448            *
449            * @param uuid the uuid
450            * @param companyId the company ID
451            * @return the number of matching repository entries
452            */
453            public static int countByUuid_C(java.lang.String uuid, long companyId) {
454                    return getPersistence().countByUuid_C(uuid, companyId);
455            }
456    
457            /**
458            * Returns all the repository entries where repositoryId = &#63;.
459            *
460            * @param repositoryId the repository ID
461            * @return the matching repository entries
462            */
463            public static List<RepositoryEntry> findByRepositoryId(long repositoryId) {
464                    return getPersistence().findByRepositoryId(repositoryId);
465            }
466    
467            /**
468            * Returns a range of all the repository entries where repositoryId = &#63;.
469            *
470            * <p>
471            * 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 RepositoryEntryModelImpl}. 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.
472            * </p>
473            *
474            * @param repositoryId the repository ID
475            * @param start the lower bound of the range of repository entries
476            * @param end the upper bound of the range of repository entries (not inclusive)
477            * @return the range of matching repository entries
478            */
479            public static List<RepositoryEntry> findByRepositoryId(long repositoryId,
480                    int start, int end) {
481                    return getPersistence().findByRepositoryId(repositoryId, start, end);
482            }
483    
484            /**
485            * Returns an ordered range of all the repository entries where repositoryId = &#63;.
486            *
487            * <p>
488            * 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 RepositoryEntryModelImpl}. 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.
489            * </p>
490            *
491            * @param repositoryId the repository ID
492            * @param start the lower bound of the range of repository entries
493            * @param end the upper bound of the range of repository entries (not inclusive)
494            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
495            * @return the ordered range of matching repository entries
496            */
497            public static List<RepositoryEntry> findByRepositoryId(long repositoryId,
498                    int start, int end, OrderByComparator<RepositoryEntry> orderByComparator) {
499                    return getPersistence()
500                                       .findByRepositoryId(repositoryId, start, end,
501                            orderByComparator);
502            }
503    
504            /**
505            * Returns the first repository entry in the ordered set where repositoryId = &#63;.
506            *
507            * @param repositoryId the repository ID
508            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
509            * @return the first matching repository entry
510            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
511            */
512            public static RepositoryEntry findByRepositoryId_First(long repositoryId,
513                    OrderByComparator<RepositoryEntry> orderByComparator)
514                    throws com.liferay.portal.NoSuchRepositoryEntryException {
515                    return getPersistence()
516                                       .findByRepositoryId_First(repositoryId, orderByComparator);
517            }
518    
519            /**
520            * Returns the first repository entry in the ordered set where repositoryId = &#63;.
521            *
522            * @param repositoryId the repository ID
523            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
524            * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found
525            */
526            public static RepositoryEntry fetchByRepositoryId_First(long repositoryId,
527                    OrderByComparator<RepositoryEntry> orderByComparator) {
528                    return getPersistence()
529                                       .fetchByRepositoryId_First(repositoryId, orderByComparator);
530            }
531    
532            /**
533            * Returns the last repository entry in the ordered set where repositoryId = &#63;.
534            *
535            * @param repositoryId the repository ID
536            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
537            * @return the last matching repository entry
538            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
539            */
540            public static RepositoryEntry findByRepositoryId_Last(long repositoryId,
541                    OrderByComparator<RepositoryEntry> orderByComparator)
542                    throws com.liferay.portal.NoSuchRepositoryEntryException {
543                    return getPersistence()
544                                       .findByRepositoryId_Last(repositoryId, orderByComparator);
545            }
546    
547            /**
548            * Returns the last repository entry in the ordered set where repositoryId = &#63;.
549            *
550            * @param repositoryId the repository ID
551            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
552            * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found
553            */
554            public static RepositoryEntry fetchByRepositoryId_Last(long repositoryId,
555                    OrderByComparator<RepositoryEntry> orderByComparator) {
556                    return getPersistence()
557                                       .fetchByRepositoryId_Last(repositoryId, orderByComparator);
558            }
559    
560            /**
561            * Returns the repository entries before and after the current repository entry in the ordered set where repositoryId = &#63;.
562            *
563            * @param repositoryEntryId the primary key of the current repository entry
564            * @param repositoryId the repository ID
565            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
566            * @return the previous, current, and next repository entry
567            * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found
568            */
569            public static RepositoryEntry[] findByRepositoryId_PrevAndNext(
570                    long repositoryEntryId, long repositoryId,
571                    OrderByComparator<RepositoryEntry> orderByComparator)
572                    throws com.liferay.portal.NoSuchRepositoryEntryException {
573                    return getPersistence()
574                                       .findByRepositoryId_PrevAndNext(repositoryEntryId,
575                            repositoryId, orderByComparator);
576            }
577    
578            /**
579            * Removes all the repository entries where repositoryId = &#63; from the database.
580            *
581            * @param repositoryId the repository ID
582            */
583            public static void removeByRepositoryId(long repositoryId) {
584                    getPersistence().removeByRepositoryId(repositoryId);
585            }
586    
587            /**
588            * Returns the number of repository entries where repositoryId = &#63;.
589            *
590            * @param repositoryId the repository ID
591            * @return the number of matching repository entries
592            */
593            public static int countByRepositoryId(long repositoryId) {
594                    return getPersistence().countByRepositoryId(repositoryId);
595            }
596    
597            /**
598            * Returns the repository entry where repositoryId = &#63; and mappedId = &#63; or throws a {@link NoSuchRepositoryEntryException} if it could not be found.
599            *
600            * @param repositoryId the repository ID
601            * @param mappedId the mapped ID
602            * @return the matching repository entry
603            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
604            */
605            public static RepositoryEntry findByR_M(long repositoryId,
606                    java.lang.String mappedId)
607                    throws com.liferay.portal.NoSuchRepositoryEntryException {
608                    return getPersistence().findByR_M(repositoryId, mappedId);
609            }
610    
611            /**
612            * Returns the repository entry where repositoryId = &#63; and mappedId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
613            *
614            * @param repositoryId the repository ID
615            * @param mappedId the mapped ID
616            * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found
617            */
618            public static RepositoryEntry fetchByR_M(long repositoryId,
619                    java.lang.String mappedId) {
620                    return getPersistence().fetchByR_M(repositoryId, mappedId);
621            }
622    
623            /**
624            * Returns the repository entry where repositoryId = &#63; and mappedId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
625            *
626            * @param repositoryId the repository ID
627            * @param mappedId the mapped ID
628            * @param retrieveFromCache whether to use the finder cache
629            * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found
630            */
631            public static RepositoryEntry fetchByR_M(long repositoryId,
632                    java.lang.String mappedId, boolean retrieveFromCache) {
633                    return getPersistence()
634                                       .fetchByR_M(repositoryId, mappedId, retrieveFromCache);
635            }
636    
637            /**
638            * Removes the repository entry where repositoryId = &#63; and mappedId = &#63; from the database.
639            *
640            * @param repositoryId the repository ID
641            * @param mappedId the mapped ID
642            * @return the repository entry that was removed
643            */
644            public static RepositoryEntry removeByR_M(long repositoryId,
645                    java.lang.String mappedId)
646                    throws com.liferay.portal.NoSuchRepositoryEntryException {
647                    return getPersistence().removeByR_M(repositoryId, mappedId);
648            }
649    
650            /**
651            * Returns the number of repository entries where repositoryId = &#63; and mappedId = &#63;.
652            *
653            * @param repositoryId the repository ID
654            * @param mappedId the mapped ID
655            * @return the number of matching repository entries
656            */
657            public static int countByR_M(long repositoryId, java.lang.String mappedId) {
658                    return getPersistence().countByR_M(repositoryId, mappedId);
659            }
660    
661            /**
662            * Caches the repository entry in the entity cache if it is enabled.
663            *
664            * @param repositoryEntry the repository entry
665            */
666            public static void cacheResult(RepositoryEntry repositoryEntry) {
667                    getPersistence().cacheResult(repositoryEntry);
668            }
669    
670            /**
671            * Caches the repository entries in the entity cache if it is enabled.
672            *
673            * @param repositoryEntries the repository entries
674            */
675            public static void cacheResult(List<RepositoryEntry> repositoryEntries) {
676                    getPersistence().cacheResult(repositoryEntries);
677            }
678    
679            /**
680            * Creates a new repository entry with the primary key. Does not add the repository entry to the database.
681            *
682            * @param repositoryEntryId the primary key for the new repository entry
683            * @return the new repository entry
684            */
685            public static RepositoryEntry create(long repositoryEntryId) {
686                    return getPersistence().create(repositoryEntryId);
687            }
688    
689            /**
690            * Removes the repository entry with the primary key from the database. Also notifies the appropriate model listeners.
691            *
692            * @param repositoryEntryId the primary key of the repository entry
693            * @return the repository entry that was removed
694            * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found
695            */
696            public static RepositoryEntry remove(long repositoryEntryId)
697                    throws com.liferay.portal.NoSuchRepositoryEntryException {
698                    return getPersistence().remove(repositoryEntryId);
699            }
700    
701            public static RepositoryEntry updateImpl(RepositoryEntry repositoryEntry) {
702                    return getPersistence().updateImpl(repositoryEntry);
703            }
704    
705            /**
706            * Returns the repository entry with the primary key or throws a {@link NoSuchRepositoryEntryException} if it could not be found.
707            *
708            * @param repositoryEntryId the primary key of the repository entry
709            * @return the repository entry
710            * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found
711            */
712            public static RepositoryEntry findByPrimaryKey(long repositoryEntryId)
713                    throws com.liferay.portal.NoSuchRepositoryEntryException {
714                    return getPersistence().findByPrimaryKey(repositoryEntryId);
715            }
716    
717            /**
718            * Returns the repository entry with the primary key or returns <code>null</code> if it could not be found.
719            *
720            * @param repositoryEntryId the primary key of the repository entry
721            * @return the repository entry, or <code>null</code> if a repository entry with the primary key could not be found
722            */
723            public static RepositoryEntry fetchByPrimaryKey(long repositoryEntryId) {
724                    return getPersistence().fetchByPrimaryKey(repositoryEntryId);
725            }
726    
727            public static java.util.Map<java.io.Serializable, RepositoryEntry> fetchByPrimaryKeys(
728                    java.util.Set<java.io.Serializable> primaryKeys) {
729                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
730            }
731    
732            /**
733            * Returns all the repository entries.
734            *
735            * @return the repository entries
736            */
737            public static List<RepositoryEntry> findAll() {
738                    return getPersistence().findAll();
739            }
740    
741            /**
742            * Returns a range of all the repository entries.
743            *
744            * <p>
745            * 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 RepositoryEntryModelImpl}. 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.
746            * </p>
747            *
748            * @param start the lower bound of the range of repository entries
749            * @param end the upper bound of the range of repository entries (not inclusive)
750            * @return the range of repository entries
751            */
752            public static List<RepositoryEntry> findAll(int start, int end) {
753                    return getPersistence().findAll(start, end);
754            }
755    
756            /**
757            * Returns an ordered range of all the repository entries.
758            *
759            * <p>
760            * 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 RepositoryEntryModelImpl}. 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.
761            * </p>
762            *
763            * @param start the lower bound of the range of repository entries
764            * @param end the upper bound of the range of repository entries (not inclusive)
765            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
766            * @return the ordered range of repository entries
767            */
768            public static List<RepositoryEntry> findAll(int start, int end,
769                    OrderByComparator<RepositoryEntry> orderByComparator) {
770                    return getPersistence().findAll(start, end, orderByComparator);
771            }
772    
773            /**
774            * Removes all the repository entries from the database.
775            */
776            public static void removeAll() {
777                    getPersistence().removeAll();
778            }
779    
780            /**
781            * Returns the number of repository entries.
782            *
783            * @return the number of repository entries
784            */
785            public static int countAll() {
786                    return getPersistence().countAll();
787            }
788    
789            public static RepositoryEntryPersistence getPersistence() {
790                    if (_persistence == null) {
791                            _persistence = (RepositoryEntryPersistence)PortalBeanLocatorUtil.locate(RepositoryEntryPersistence.class.getName());
792    
793                            ReferenceRegistry.registerReference(RepositoryEntryUtil.class,
794                                    "_persistence");
795                    }
796    
797                    return _persistence;
798            }
799    
800            /**
801             * @deprecated As of 6.2.0
802             */
803            @Deprecated
804            public void setPersistence(RepositoryEntryPersistence persistence) {
805            }
806    
807            private static RepositoryEntryPersistence _persistence;
808    }