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