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 an ordered range of all the repository entries where uuid = &#63;.
158            *
159            * <p>
160            * 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.
161            * </p>
162            *
163            * @param uuid the uuid
164            * @param start the lower bound of the range of repository entries
165            * @param end the upper bound of the range of repository entries (not inclusive)
166            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
167            * @param retrieveFromCache whether to retrieve from the finder cache
168            * @return the ordered range of matching repository entries
169            */
170            public static List<RepositoryEntry> findByUuid(java.lang.String uuid,
171                    int start, int end,
172                    OrderByComparator<RepositoryEntry> orderByComparator,
173                    boolean retrieveFromCache) {
174                    return getPersistence()
175                                       .findByUuid(uuid, start, end, orderByComparator,
176                            retrieveFromCache);
177            }
178    
179            /**
180            * Returns the first repository entry in the ordered set where uuid = &#63;.
181            *
182            * @param uuid the uuid
183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
184            * @return the first matching repository entry
185            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
186            */
187            public static RepositoryEntry findByUuid_First(java.lang.String uuid,
188                    OrderByComparator<RepositoryEntry> orderByComparator)
189                    throws com.liferay.portal.NoSuchRepositoryEntryException {
190                    return getPersistence().findByUuid_First(uuid, orderByComparator);
191            }
192    
193            /**
194            * Returns the first repository entry in the ordered set where uuid = &#63;.
195            *
196            * @param uuid the uuid
197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
198            * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found
199            */
200            public static RepositoryEntry fetchByUuid_First(java.lang.String uuid,
201                    OrderByComparator<RepositoryEntry> orderByComparator) {
202                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
203            }
204    
205            /**
206            * Returns the last repository entry in the ordered set where uuid = &#63;.
207            *
208            * @param uuid the uuid
209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
210            * @return the last matching repository entry
211            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
212            */
213            public static RepositoryEntry findByUuid_Last(java.lang.String uuid,
214                    OrderByComparator<RepositoryEntry> orderByComparator)
215                    throws com.liferay.portal.NoSuchRepositoryEntryException {
216                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
217            }
218    
219            /**
220            * Returns the last repository entry in the ordered set where uuid = &#63;.
221            *
222            * @param uuid the uuid
223            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
224            * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found
225            */
226            public static RepositoryEntry fetchByUuid_Last(java.lang.String uuid,
227                    OrderByComparator<RepositoryEntry> orderByComparator) {
228                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
229            }
230    
231            /**
232            * Returns the repository entries before and after the current repository entry in the ordered set where uuid = &#63;.
233            *
234            * @param repositoryEntryId the primary key of the current repository entry
235            * @param uuid the uuid
236            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
237            * @return the previous, current, and next repository entry
238            * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found
239            */
240            public static RepositoryEntry[] findByUuid_PrevAndNext(
241                    long repositoryEntryId, java.lang.String uuid,
242                    OrderByComparator<RepositoryEntry> orderByComparator)
243                    throws com.liferay.portal.NoSuchRepositoryEntryException {
244                    return getPersistence()
245                                       .findByUuid_PrevAndNext(repositoryEntryId, uuid,
246                            orderByComparator);
247            }
248    
249            /**
250            * Removes all the repository entries where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            */
254            public static void removeByUuid(java.lang.String uuid) {
255                    getPersistence().removeByUuid(uuid);
256            }
257    
258            /**
259            * Returns the number of repository entries where uuid = &#63;.
260            *
261            * @param uuid the uuid
262            * @return the number of matching repository entries
263            */
264            public static int countByUuid(java.lang.String uuid) {
265                    return getPersistence().countByUuid(uuid);
266            }
267    
268            /**
269            * Returns the repository entry where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchRepositoryEntryException} if it could not be found.
270            *
271            * @param uuid the uuid
272            * @param groupId the group ID
273            * @return the matching repository entry
274            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
275            */
276            public static RepositoryEntry findByUUID_G(java.lang.String uuid,
277                    long groupId) throws com.liferay.portal.NoSuchRepositoryEntryException {
278                    return getPersistence().findByUUID_G(uuid, groupId);
279            }
280    
281            /**
282            * 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.
283            *
284            * @param uuid the uuid
285            * @param groupId the group ID
286            * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found
287            */
288            public static RepositoryEntry fetchByUUID_G(java.lang.String uuid,
289                    long groupId) {
290                    return getPersistence().fetchByUUID_G(uuid, groupId);
291            }
292    
293            /**
294            * 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.
295            *
296            * @param uuid the uuid
297            * @param groupId the group ID
298            * @param retrieveFromCache whether to retrieve from the finder cache
299            * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found
300            */
301            public static RepositoryEntry fetchByUUID_G(java.lang.String uuid,
302                    long groupId, boolean retrieveFromCache) {
303                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
304            }
305    
306            /**
307            * Removes the repository entry where uuid = &#63; and groupId = &#63; from the database.
308            *
309            * @param uuid the uuid
310            * @param groupId the group ID
311            * @return the repository entry that was removed
312            */
313            public static RepositoryEntry removeByUUID_G(java.lang.String uuid,
314                    long groupId) throws com.liferay.portal.NoSuchRepositoryEntryException {
315                    return getPersistence().removeByUUID_G(uuid, groupId);
316            }
317    
318            /**
319            * Returns the number of repository entries where uuid = &#63; and groupId = &#63;.
320            *
321            * @param uuid the uuid
322            * @param groupId the group ID
323            * @return the number of matching repository entries
324            */
325            public static int countByUUID_G(java.lang.String uuid, long groupId) {
326                    return getPersistence().countByUUID_G(uuid, groupId);
327            }
328    
329            /**
330            * Returns all the repository entries where uuid = &#63; and companyId = &#63;.
331            *
332            * @param uuid the uuid
333            * @param companyId the company ID
334            * @return the matching repository entries
335            */
336            public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid,
337                    long companyId) {
338                    return getPersistence().findByUuid_C(uuid, companyId);
339            }
340    
341            /**
342            * Returns a range of all the repository entries where uuid = &#63; and companyId = &#63;.
343            *
344            * <p>
345            * 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.
346            * </p>
347            *
348            * @param uuid the uuid
349            * @param companyId the company ID
350            * @param start the lower bound of the range of repository entries
351            * @param end the upper bound of the range of repository entries (not inclusive)
352            * @return the range of matching repository entries
353            */
354            public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid,
355                    long companyId, int start, int end) {
356                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
357            }
358    
359            /**
360            * Returns an ordered range of all the repository entries where uuid = &#63; and companyId = &#63;.
361            *
362            * <p>
363            * 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.
364            * </p>
365            *
366            * @param uuid the uuid
367            * @param companyId the company ID
368            * @param start the lower bound of the range of repository entries
369            * @param end the upper bound of the range of repository entries (not inclusive)
370            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
371            * @return the ordered range of matching repository entries
372            */
373            public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid,
374                    long companyId, int start, int end,
375                    OrderByComparator<RepositoryEntry> orderByComparator) {
376                    return getPersistence()
377                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
378            }
379    
380            /**
381            * Returns an ordered range of all the repository entries where uuid = &#63; and companyId = &#63;.
382            *
383            * <p>
384            * 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.
385            * </p>
386            *
387            * @param uuid the uuid
388            * @param companyId the company ID
389            * @param start the lower bound of the range of repository entries
390            * @param end the upper bound of the range of repository entries (not inclusive)
391            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
392            * @param retrieveFromCache whether to retrieve from the finder cache
393            * @return the ordered range of matching repository entries
394            */
395            public static List<RepositoryEntry> findByUuid_C(java.lang.String uuid,
396                    long companyId, int start, int end,
397                    OrderByComparator<RepositoryEntry> orderByComparator,
398                    boolean retrieveFromCache) {
399                    return getPersistence()
400                                       .findByUuid_C(uuid, companyId, start, end,
401                            orderByComparator, retrieveFromCache);
402            }
403    
404            /**
405            * Returns the first repository entry in the ordered set where uuid = &#63; and companyId = &#63;.
406            *
407            * @param uuid the uuid
408            * @param companyId the company ID
409            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
410            * @return the first matching repository entry
411            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
412            */
413            public static RepositoryEntry findByUuid_C_First(java.lang.String uuid,
414                    long companyId, OrderByComparator<RepositoryEntry> orderByComparator)
415                    throws com.liferay.portal.NoSuchRepositoryEntryException {
416                    return getPersistence()
417                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
418            }
419    
420            /**
421            * Returns the first repository entry in the ordered set where uuid = &#63; and companyId = &#63;.
422            *
423            * @param uuid the uuid
424            * @param companyId the company ID
425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
426            * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found
427            */
428            public static RepositoryEntry fetchByUuid_C_First(java.lang.String uuid,
429                    long companyId, OrderByComparator<RepositoryEntry> orderByComparator) {
430                    return getPersistence()
431                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
432            }
433    
434            /**
435            * Returns the last repository entry in the ordered set where uuid = &#63; and companyId = &#63;.
436            *
437            * @param uuid the uuid
438            * @param companyId the company ID
439            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
440            * @return the last matching repository entry
441            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
442            */
443            public static RepositoryEntry findByUuid_C_Last(java.lang.String uuid,
444                    long companyId, OrderByComparator<RepositoryEntry> orderByComparator)
445                    throws com.liferay.portal.NoSuchRepositoryEntryException {
446                    return getPersistence()
447                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
448            }
449    
450            /**
451            * Returns the last repository entry in the ordered set where uuid = &#63; and companyId = &#63;.
452            *
453            * @param uuid the uuid
454            * @param companyId the company ID
455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
456            * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found
457            */
458            public static RepositoryEntry fetchByUuid_C_Last(java.lang.String uuid,
459                    long companyId, OrderByComparator<RepositoryEntry> orderByComparator) {
460                    return getPersistence()
461                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
462            }
463    
464            /**
465            * Returns the repository entries before and after the current repository entry in the ordered set where uuid = &#63; and companyId = &#63;.
466            *
467            * @param repositoryEntryId the primary key of the current repository entry
468            * @param uuid the uuid
469            * @param companyId the company ID
470            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
471            * @return the previous, current, and next repository entry
472            * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found
473            */
474            public static RepositoryEntry[] findByUuid_C_PrevAndNext(
475                    long repositoryEntryId, java.lang.String uuid, long companyId,
476                    OrderByComparator<RepositoryEntry> orderByComparator)
477                    throws com.liferay.portal.NoSuchRepositoryEntryException {
478                    return getPersistence()
479                                       .findByUuid_C_PrevAndNext(repositoryEntryId, uuid,
480                            companyId, orderByComparator);
481            }
482    
483            /**
484            * Removes all the repository entries where uuid = &#63; and companyId = &#63; from the database.
485            *
486            * @param uuid the uuid
487            * @param companyId the company ID
488            */
489            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
490                    getPersistence().removeByUuid_C(uuid, companyId);
491            }
492    
493            /**
494            * Returns the number of repository entries where uuid = &#63; and companyId = &#63;.
495            *
496            * @param uuid the uuid
497            * @param companyId the company ID
498            * @return the number of matching repository entries
499            */
500            public static int countByUuid_C(java.lang.String uuid, long companyId) {
501                    return getPersistence().countByUuid_C(uuid, companyId);
502            }
503    
504            /**
505            * Returns all the repository entries where repositoryId = &#63;.
506            *
507            * @param repositoryId the repository ID
508            * @return the matching repository entries
509            */
510            public static List<RepositoryEntry> findByRepositoryId(long repositoryId) {
511                    return getPersistence().findByRepositoryId(repositoryId);
512            }
513    
514            /**
515            * Returns a range of all the repository entries where repositoryId = &#63;.
516            *
517            * <p>
518            * 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.
519            * </p>
520            *
521            * @param repositoryId the repository ID
522            * @param start the lower bound of the range of repository entries
523            * @param end the upper bound of the range of repository entries (not inclusive)
524            * @return the range of matching repository entries
525            */
526            public static List<RepositoryEntry> findByRepositoryId(long repositoryId,
527                    int start, int end) {
528                    return getPersistence().findByRepositoryId(repositoryId, start, end);
529            }
530    
531            /**
532            * Returns an ordered range of all the repository entries where repositoryId = &#63;.
533            *
534            * <p>
535            * 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.
536            * </p>
537            *
538            * @param repositoryId the repository ID
539            * @param start the lower bound of the range of repository entries
540            * @param end the upper bound of the range of repository entries (not inclusive)
541            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
542            * @return the ordered range of matching repository entries
543            */
544            public static List<RepositoryEntry> findByRepositoryId(long repositoryId,
545                    int start, int end, OrderByComparator<RepositoryEntry> orderByComparator) {
546                    return getPersistence()
547                                       .findByRepositoryId(repositoryId, start, end,
548                            orderByComparator);
549            }
550    
551            /**
552            * Returns an ordered range of all the repository entries where repositoryId = &#63;.
553            *
554            * <p>
555            * 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.
556            * </p>
557            *
558            * @param repositoryId the repository ID
559            * @param start the lower bound of the range of repository entries
560            * @param end the upper bound of the range of repository entries (not inclusive)
561            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
562            * @param retrieveFromCache whether to retrieve from the finder cache
563            * @return the ordered range of matching repository entries
564            */
565            public static List<RepositoryEntry> findByRepositoryId(long repositoryId,
566                    int start, int end,
567                    OrderByComparator<RepositoryEntry> orderByComparator,
568                    boolean retrieveFromCache) {
569                    return getPersistence()
570                                       .findByRepositoryId(repositoryId, start, end,
571                            orderByComparator, retrieveFromCache);
572            }
573    
574            /**
575            * Returns the first repository entry in the ordered set where repositoryId = &#63;.
576            *
577            * @param repositoryId the repository ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the first matching repository entry
580            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
581            */
582            public static RepositoryEntry findByRepositoryId_First(long repositoryId,
583                    OrderByComparator<RepositoryEntry> orderByComparator)
584                    throws com.liferay.portal.NoSuchRepositoryEntryException {
585                    return getPersistence()
586                                       .findByRepositoryId_First(repositoryId, orderByComparator);
587            }
588    
589            /**
590            * Returns the first repository entry in the ordered set where repositoryId = &#63;.
591            *
592            * @param repositoryId the repository ID
593            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
594            * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found
595            */
596            public static RepositoryEntry fetchByRepositoryId_First(long repositoryId,
597                    OrderByComparator<RepositoryEntry> orderByComparator) {
598                    return getPersistence()
599                                       .fetchByRepositoryId_First(repositoryId, orderByComparator);
600            }
601    
602            /**
603            * Returns the last repository entry in the ordered set where repositoryId = &#63;.
604            *
605            * @param repositoryId the repository ID
606            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
607            * @return the last matching repository entry
608            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
609            */
610            public static RepositoryEntry findByRepositoryId_Last(long repositoryId,
611                    OrderByComparator<RepositoryEntry> orderByComparator)
612                    throws com.liferay.portal.NoSuchRepositoryEntryException {
613                    return getPersistence()
614                                       .findByRepositoryId_Last(repositoryId, orderByComparator);
615            }
616    
617            /**
618            * Returns the last repository entry in the ordered set where repositoryId = &#63;.
619            *
620            * @param repositoryId the repository ID
621            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
622            * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found
623            */
624            public static RepositoryEntry fetchByRepositoryId_Last(long repositoryId,
625                    OrderByComparator<RepositoryEntry> orderByComparator) {
626                    return getPersistence()
627                                       .fetchByRepositoryId_Last(repositoryId, orderByComparator);
628            }
629    
630            /**
631            * Returns the repository entries before and after the current repository entry in the ordered set where repositoryId = &#63;.
632            *
633            * @param repositoryEntryId the primary key of the current repository entry
634            * @param repositoryId the repository ID
635            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
636            * @return the previous, current, and next repository entry
637            * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found
638            */
639            public static RepositoryEntry[] findByRepositoryId_PrevAndNext(
640                    long repositoryEntryId, long repositoryId,
641                    OrderByComparator<RepositoryEntry> orderByComparator)
642                    throws com.liferay.portal.NoSuchRepositoryEntryException {
643                    return getPersistence()
644                                       .findByRepositoryId_PrevAndNext(repositoryEntryId,
645                            repositoryId, orderByComparator);
646            }
647    
648            /**
649            * Removes all the repository entries where repositoryId = &#63; from the database.
650            *
651            * @param repositoryId the repository ID
652            */
653            public static void removeByRepositoryId(long repositoryId) {
654                    getPersistence().removeByRepositoryId(repositoryId);
655            }
656    
657            /**
658            * Returns the number of repository entries where repositoryId = &#63;.
659            *
660            * @param repositoryId the repository ID
661            * @return the number of matching repository entries
662            */
663            public static int countByRepositoryId(long repositoryId) {
664                    return getPersistence().countByRepositoryId(repositoryId);
665            }
666    
667            /**
668            * Returns the repository entry where repositoryId = &#63; and mappedId = &#63; or throws a {@link NoSuchRepositoryEntryException} if it could not be found.
669            *
670            * @param repositoryId the repository ID
671            * @param mappedId the mapped ID
672            * @return the matching repository entry
673            * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found
674            */
675            public static RepositoryEntry findByR_M(long repositoryId,
676                    java.lang.String mappedId)
677                    throws com.liferay.portal.NoSuchRepositoryEntryException {
678                    return getPersistence().findByR_M(repositoryId, mappedId);
679            }
680    
681            /**
682            * 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.
683            *
684            * @param repositoryId the repository ID
685            * @param mappedId the mapped ID
686            * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found
687            */
688            public static RepositoryEntry fetchByR_M(long repositoryId,
689                    java.lang.String mappedId) {
690                    return getPersistence().fetchByR_M(repositoryId, mappedId);
691            }
692    
693            /**
694            * 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.
695            *
696            * @param repositoryId the repository ID
697            * @param mappedId the mapped ID
698            * @param retrieveFromCache whether to retrieve from the finder cache
699            * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found
700            */
701            public static RepositoryEntry fetchByR_M(long repositoryId,
702                    java.lang.String mappedId, boolean retrieveFromCache) {
703                    return getPersistence()
704                                       .fetchByR_M(repositoryId, mappedId, retrieveFromCache);
705            }
706    
707            /**
708            * Removes the repository entry where repositoryId = &#63; and mappedId = &#63; from the database.
709            *
710            * @param repositoryId the repository ID
711            * @param mappedId the mapped ID
712            * @return the repository entry that was removed
713            */
714            public static RepositoryEntry removeByR_M(long repositoryId,
715                    java.lang.String mappedId)
716                    throws com.liferay.portal.NoSuchRepositoryEntryException {
717                    return getPersistence().removeByR_M(repositoryId, mappedId);
718            }
719    
720            /**
721            * Returns the number of repository entries where repositoryId = &#63; and mappedId = &#63;.
722            *
723            * @param repositoryId the repository ID
724            * @param mappedId the mapped ID
725            * @return the number of matching repository entries
726            */
727            public static int countByR_M(long repositoryId, java.lang.String mappedId) {
728                    return getPersistence().countByR_M(repositoryId, mappedId);
729            }
730    
731            /**
732            * Caches the repository entry in the entity cache if it is enabled.
733            *
734            * @param repositoryEntry the repository entry
735            */
736            public static void cacheResult(RepositoryEntry repositoryEntry) {
737                    getPersistence().cacheResult(repositoryEntry);
738            }
739    
740            /**
741            * Caches the repository entries in the entity cache if it is enabled.
742            *
743            * @param repositoryEntries the repository entries
744            */
745            public static void cacheResult(List<RepositoryEntry> repositoryEntries) {
746                    getPersistence().cacheResult(repositoryEntries);
747            }
748    
749            /**
750            * Creates a new repository entry with the primary key. Does not add the repository entry to the database.
751            *
752            * @param repositoryEntryId the primary key for the new repository entry
753            * @return the new repository entry
754            */
755            public static RepositoryEntry create(long repositoryEntryId) {
756                    return getPersistence().create(repositoryEntryId);
757            }
758    
759            /**
760            * Removes the repository entry with the primary key from the database. Also notifies the appropriate model listeners.
761            *
762            * @param repositoryEntryId the primary key of the repository entry
763            * @return the repository entry that was removed
764            * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found
765            */
766            public static RepositoryEntry remove(long repositoryEntryId)
767                    throws com.liferay.portal.NoSuchRepositoryEntryException {
768                    return getPersistence().remove(repositoryEntryId);
769            }
770    
771            public static RepositoryEntry updateImpl(RepositoryEntry repositoryEntry) {
772                    return getPersistence().updateImpl(repositoryEntry);
773            }
774    
775            /**
776            * Returns the repository entry with the primary key or throws a {@link NoSuchRepositoryEntryException} if it could not be found.
777            *
778            * @param repositoryEntryId the primary key of the repository entry
779            * @return the repository entry
780            * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found
781            */
782            public static RepositoryEntry findByPrimaryKey(long repositoryEntryId)
783                    throws com.liferay.portal.NoSuchRepositoryEntryException {
784                    return getPersistence().findByPrimaryKey(repositoryEntryId);
785            }
786    
787            /**
788            * Returns the repository entry with the primary key or returns <code>null</code> if it could not be found.
789            *
790            * @param repositoryEntryId the primary key of the repository entry
791            * @return the repository entry, or <code>null</code> if a repository entry with the primary key could not be found
792            */
793            public static RepositoryEntry fetchByPrimaryKey(long repositoryEntryId) {
794                    return getPersistence().fetchByPrimaryKey(repositoryEntryId);
795            }
796    
797            public static java.util.Map<java.io.Serializable, RepositoryEntry> fetchByPrimaryKeys(
798                    java.util.Set<java.io.Serializable> primaryKeys) {
799                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
800            }
801    
802            /**
803            * Returns all the repository entries.
804            *
805            * @return the repository entries
806            */
807            public static List<RepositoryEntry> findAll() {
808                    return getPersistence().findAll();
809            }
810    
811            /**
812            * Returns a range of all the repository entries.
813            *
814            * <p>
815            * 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.
816            * </p>
817            *
818            * @param start the lower bound of the range of repository entries
819            * @param end the upper bound of the range of repository entries (not inclusive)
820            * @return the range of repository entries
821            */
822            public static List<RepositoryEntry> findAll(int start, int end) {
823                    return getPersistence().findAll(start, end);
824            }
825    
826            /**
827            * Returns an ordered range of all the repository entries.
828            *
829            * <p>
830            * 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.
831            * </p>
832            *
833            * @param start the lower bound of the range of repository entries
834            * @param end the upper bound of the range of repository entries (not inclusive)
835            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
836            * @return the ordered range of repository entries
837            */
838            public static List<RepositoryEntry> findAll(int start, int end,
839                    OrderByComparator<RepositoryEntry> orderByComparator) {
840                    return getPersistence().findAll(start, end, orderByComparator);
841            }
842    
843            /**
844            * Returns an ordered range of all the repository entries.
845            *
846            * <p>
847            * 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.
848            * </p>
849            *
850            * @param start the lower bound of the range of repository entries
851            * @param end the upper bound of the range of repository entries (not inclusive)
852            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
853            * @param retrieveFromCache whether to retrieve from the finder cache
854            * @return the ordered range of repository entries
855            */
856            public static List<RepositoryEntry> findAll(int start, int end,
857                    OrderByComparator<RepositoryEntry> orderByComparator,
858                    boolean retrieveFromCache) {
859                    return getPersistence()
860                                       .findAll(start, end, orderByComparator, retrieveFromCache);
861            }
862    
863            /**
864            * Removes all the repository entries from the database.
865            */
866            public static void removeAll() {
867                    getPersistence().removeAll();
868            }
869    
870            /**
871            * Returns the number of repository entries.
872            *
873            * @return the number of repository entries
874            */
875            public static int countAll() {
876                    return getPersistence().countAll();
877            }
878    
879            public static java.util.Set<java.lang.String> getBadColumnNames() {
880                    return getPersistence().getBadColumnNames();
881            }
882    
883            public static RepositoryEntryPersistence getPersistence() {
884                    if (_persistence == null) {
885                            _persistence = (RepositoryEntryPersistence)PortalBeanLocatorUtil.locate(RepositoryEntryPersistence.class.getName());
886    
887                            ReferenceRegistry.registerReference(RepositoryEntryUtil.class,
888                                    "_persistence");
889                    }
890    
891                    return _persistence;
892            }
893    
894            /**
895             * @deprecated As of 6.2.0
896             */
897            @Deprecated
898            public void setPersistence(RepositoryEntryPersistence persistence) {
899            }
900    
901            private static RepositoryEntryPersistence _persistence;
902    }