001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.documentlibrary.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.documentlibrary.model.DLFileEntry;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the document library file entry service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see DLFileEntryPersistence
038     * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class DLFileEntryUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(DLFileEntry dlFileEntry) {
060                    getPersistence().clearCache(dlFileEntry);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<DLFileEntry> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<DLFileEntry> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<DLFileEntry> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<DLFileEntry> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static DLFileEntry update(DLFileEntry dlFileEntry) {
101                    return getPersistence().update(dlFileEntry);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static DLFileEntry update(DLFileEntry dlFileEntry,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(dlFileEntry, serviceContext);
110            }
111    
112            /**
113            * Returns all the document library file entries where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching document library file entries
117            */
118            public static List<DLFileEntry> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the document library file entries where uuid = &#63;.
124            *
125            * <p>
126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of document library file entries
131            * @param end the upper bound of the range of document library file entries (not inclusive)
132            * @return the range of matching document library file entries
133            */
134            public static List<DLFileEntry> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the document library file entries where uuid = &#63;.
141            *
142            * <p>
143            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of document library file entries
148            * @param end the upper bound of the range of document library file entries (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching document library file entries
151            */
152            public static List<DLFileEntry> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns an ordered range of all the document library file entries where uuid = &#63;.
159            *
160            * <p>
161            * 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 DLFileEntryModelImpl}. 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.
162            * </p>
163            *
164            * @param uuid the uuid
165            * @param start the lower bound of the range of document library file entries
166            * @param end the upper bound of the range of document library file entries (not inclusive)
167            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
168            * @param retrieveFromCache whether to retrieve from the finder cache
169            * @return the ordered range of matching document library file entries
170            */
171            public static List<DLFileEntry> findByUuid(java.lang.String uuid,
172                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator,
173                    boolean retrieveFromCache) {
174                    return getPersistence()
175                                       .findByUuid(uuid, start, end, orderByComparator,
176                            retrieveFromCache);
177            }
178    
179            /**
180            * Returns the first document library file 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 document library file entry
185            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
186            */
187            public static DLFileEntry findByUuid_First(java.lang.String uuid,
188                    OrderByComparator<DLFileEntry> orderByComparator)
189                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
190                    return getPersistence().findByUuid_First(uuid, orderByComparator);
191            }
192    
193            /**
194            * Returns the first document library file 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 document library file entry, or <code>null</code> if a matching document library file entry could not be found
199            */
200            public static DLFileEntry fetchByUuid_First(java.lang.String uuid,
201                    OrderByComparator<DLFileEntry> orderByComparator) {
202                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
203            }
204    
205            /**
206            * Returns the last document library file 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 document library file entry
211            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
212            */
213            public static DLFileEntry findByUuid_Last(java.lang.String uuid,
214                    OrderByComparator<DLFileEntry> orderByComparator)
215                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
216                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
217            }
218    
219            /**
220            * Returns the last document library file 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 document library file entry, or <code>null</code> if a matching document library file entry could not be found
225            */
226            public static DLFileEntry fetchByUuid_Last(java.lang.String uuid,
227                    OrderByComparator<DLFileEntry> orderByComparator) {
228                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
229            }
230    
231            /**
232            * Returns the document library file entries before and after the current document library file entry in the ordered set where uuid = &#63;.
233            *
234            * @param fileEntryId the primary key of the current document library file 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 document library file entry
238            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
239            */
240            public static DLFileEntry[] findByUuid_PrevAndNext(long fileEntryId,
241                    java.lang.String uuid, OrderByComparator<DLFileEntry> orderByComparator)
242                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
243                    return getPersistence()
244                                       .findByUuid_PrevAndNext(fileEntryId, uuid, orderByComparator);
245            }
246    
247            /**
248            * Removes all the document library file entries where uuid = &#63; from the database.
249            *
250            * @param uuid the uuid
251            */
252            public static void removeByUuid(java.lang.String uuid) {
253                    getPersistence().removeByUuid(uuid);
254            }
255    
256            /**
257            * Returns the number of document library file entries where uuid = &#63;.
258            *
259            * @param uuid the uuid
260            * @return the number of matching document library file entries
261            */
262            public static int countByUuid(java.lang.String uuid) {
263                    return getPersistence().countByUuid(uuid);
264            }
265    
266            /**
267            * Returns the document library file entry where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchFileEntryException} if it could not be found.
268            *
269            * @param uuid the uuid
270            * @param groupId the group ID
271            * @return the matching document library file entry
272            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
273            */
274            public static DLFileEntry findByUUID_G(java.lang.String uuid, long groupId)
275                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
276                    return getPersistence().findByUUID_G(uuid, groupId);
277            }
278    
279            /**
280            * Returns the document library file entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
281            *
282            * @param uuid the uuid
283            * @param groupId the group ID
284            * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
285            */
286            public static DLFileEntry fetchByUUID_G(java.lang.String uuid, long groupId) {
287                    return getPersistence().fetchByUUID_G(uuid, groupId);
288            }
289    
290            /**
291            * Returns the document library file entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
292            *
293            * @param uuid the uuid
294            * @param groupId the group ID
295            * @param retrieveFromCache whether to retrieve from the finder cache
296            * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
297            */
298            public static DLFileEntry fetchByUUID_G(java.lang.String uuid,
299                    long groupId, boolean retrieveFromCache) {
300                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
301            }
302    
303            /**
304            * Removes the document library file entry where uuid = &#63; and groupId = &#63; from the database.
305            *
306            * @param uuid the uuid
307            * @param groupId the group ID
308            * @return the document library file entry that was removed
309            */
310            public static DLFileEntry removeByUUID_G(java.lang.String uuid, long groupId)
311                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
312                    return getPersistence().removeByUUID_G(uuid, groupId);
313            }
314    
315            /**
316            * Returns the number of document library file entries where uuid = &#63; and groupId = &#63;.
317            *
318            * @param uuid the uuid
319            * @param groupId the group ID
320            * @return the number of matching document library file entries
321            */
322            public static int countByUUID_G(java.lang.String uuid, long groupId) {
323                    return getPersistence().countByUUID_G(uuid, groupId);
324            }
325    
326            /**
327            * Returns all the document library file entries where uuid = &#63; and companyId = &#63;.
328            *
329            * @param uuid the uuid
330            * @param companyId the company ID
331            * @return the matching document library file entries
332            */
333            public static List<DLFileEntry> findByUuid_C(java.lang.String uuid,
334                    long companyId) {
335                    return getPersistence().findByUuid_C(uuid, companyId);
336            }
337    
338            /**
339            * Returns a range of all the document library file entries where uuid = &#63; and companyId = &#63;.
340            *
341            * <p>
342            * 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 DLFileEntryModelImpl}. 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.
343            * </p>
344            *
345            * @param uuid the uuid
346            * @param companyId the company ID
347            * @param start the lower bound of the range of document library file entries
348            * @param end the upper bound of the range of document library file entries (not inclusive)
349            * @return the range of matching document library file entries
350            */
351            public static List<DLFileEntry> findByUuid_C(java.lang.String uuid,
352                    long companyId, int start, int end) {
353                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
354            }
355    
356            /**
357            * Returns an ordered range of all the document library file entries where uuid = &#63; and companyId = &#63;.
358            *
359            * <p>
360            * 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 DLFileEntryModelImpl}. 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.
361            * </p>
362            *
363            * @param uuid the uuid
364            * @param companyId the company ID
365            * @param start the lower bound of the range of document library file entries
366            * @param end the upper bound of the range of document library file entries (not inclusive)
367            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
368            * @return the ordered range of matching document library file entries
369            */
370            public static List<DLFileEntry> findByUuid_C(java.lang.String uuid,
371                    long companyId, int start, int end,
372                    OrderByComparator<DLFileEntry> orderByComparator) {
373                    return getPersistence()
374                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
375            }
376    
377            /**
378            * Returns an ordered range of all the document library file entries where uuid = &#63; and companyId = &#63;.
379            *
380            * <p>
381            * 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 DLFileEntryModelImpl}. 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.
382            * </p>
383            *
384            * @param uuid the uuid
385            * @param companyId the company ID
386            * @param start the lower bound of the range of document library file entries
387            * @param end the upper bound of the range of document library file entries (not inclusive)
388            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
389            * @param retrieveFromCache whether to retrieve from the finder cache
390            * @return the ordered range of matching document library file entries
391            */
392            public static List<DLFileEntry> findByUuid_C(java.lang.String uuid,
393                    long companyId, int start, int end,
394                    OrderByComparator<DLFileEntry> orderByComparator,
395                    boolean retrieveFromCache) {
396                    return getPersistence()
397                                       .findByUuid_C(uuid, companyId, start, end,
398                            orderByComparator, retrieveFromCache);
399            }
400    
401            /**
402            * Returns the first document library file entry in the ordered set where uuid = &#63; and companyId = &#63;.
403            *
404            * @param uuid the uuid
405            * @param companyId the company ID
406            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
407            * @return the first matching document library file entry
408            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
409            */
410            public static DLFileEntry findByUuid_C_First(java.lang.String uuid,
411                    long companyId, OrderByComparator<DLFileEntry> orderByComparator)
412                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
413                    return getPersistence()
414                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
415            }
416    
417            /**
418            * Returns the first document library file entry in the ordered set where uuid = &#63; and companyId = &#63;.
419            *
420            * @param uuid the uuid
421            * @param companyId the company ID
422            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
423            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
424            */
425            public static DLFileEntry fetchByUuid_C_First(java.lang.String uuid,
426                    long companyId, OrderByComparator<DLFileEntry> orderByComparator) {
427                    return getPersistence()
428                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
429            }
430    
431            /**
432            * Returns the last document library file entry in the ordered set where uuid = &#63; and companyId = &#63;.
433            *
434            * @param uuid the uuid
435            * @param companyId the company ID
436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
437            * @return the last matching document library file entry
438            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
439            */
440            public static DLFileEntry findByUuid_C_Last(java.lang.String uuid,
441                    long companyId, OrderByComparator<DLFileEntry> orderByComparator)
442                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
443                    return getPersistence()
444                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
445            }
446    
447            /**
448            * Returns the last document library file entry in the ordered set where uuid = &#63; and companyId = &#63;.
449            *
450            * @param uuid the uuid
451            * @param companyId the company ID
452            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
453            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
454            */
455            public static DLFileEntry fetchByUuid_C_Last(java.lang.String uuid,
456                    long companyId, OrderByComparator<DLFileEntry> orderByComparator) {
457                    return getPersistence()
458                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
459            }
460    
461            /**
462            * Returns the document library file entries before and after the current document library file entry in the ordered set where uuid = &#63; and companyId = &#63;.
463            *
464            * @param fileEntryId the primary key of the current document library file entry
465            * @param uuid the uuid
466            * @param companyId the company ID
467            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
468            * @return the previous, current, and next document library file entry
469            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
470            */
471            public static DLFileEntry[] findByUuid_C_PrevAndNext(long fileEntryId,
472                    java.lang.String uuid, long companyId,
473                    OrderByComparator<DLFileEntry> orderByComparator)
474                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
475                    return getPersistence()
476                                       .findByUuid_C_PrevAndNext(fileEntryId, uuid, companyId,
477                            orderByComparator);
478            }
479    
480            /**
481            * Removes all the document library file entries where uuid = &#63; and companyId = &#63; from the database.
482            *
483            * @param uuid the uuid
484            * @param companyId the company ID
485            */
486            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
487                    getPersistence().removeByUuid_C(uuid, companyId);
488            }
489    
490            /**
491            * Returns the number of document library file entries where uuid = &#63; and companyId = &#63;.
492            *
493            * @param uuid the uuid
494            * @param companyId the company ID
495            * @return the number of matching document library file entries
496            */
497            public static int countByUuid_C(java.lang.String uuid, long companyId) {
498                    return getPersistence().countByUuid_C(uuid, companyId);
499            }
500    
501            /**
502            * Returns all the document library file entries where groupId = &#63;.
503            *
504            * @param groupId the group ID
505            * @return the matching document library file entries
506            */
507            public static List<DLFileEntry> findByGroupId(long groupId) {
508                    return getPersistence().findByGroupId(groupId);
509            }
510    
511            /**
512            * Returns a range of all the document library file entries where groupId = &#63;.
513            *
514            * <p>
515            * 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 DLFileEntryModelImpl}. 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.
516            * </p>
517            *
518            * @param groupId the group ID
519            * @param start the lower bound of the range of document library file entries
520            * @param end the upper bound of the range of document library file entries (not inclusive)
521            * @return the range of matching document library file entries
522            */
523            public static List<DLFileEntry> findByGroupId(long groupId, int start,
524                    int end) {
525                    return getPersistence().findByGroupId(groupId, start, end);
526            }
527    
528            /**
529            * Returns an ordered range of all the document library file entries where groupId = &#63;.
530            *
531            * <p>
532            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
533            * </p>
534            *
535            * @param groupId the group ID
536            * @param start the lower bound of the range of document library file entries
537            * @param end the upper bound of the range of document library file entries (not inclusive)
538            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
539            * @return the ordered range of matching document library file entries
540            */
541            public static List<DLFileEntry> findByGroupId(long groupId, int start,
542                    int end, OrderByComparator<DLFileEntry> orderByComparator) {
543                    return getPersistence()
544                                       .findByGroupId(groupId, start, end, orderByComparator);
545            }
546    
547            /**
548            * Returns an ordered range of all the document library file entries where groupId = &#63;.
549            *
550            * <p>
551            * 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 DLFileEntryModelImpl}. 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.
552            * </p>
553            *
554            * @param groupId the group ID
555            * @param start the lower bound of the range of document library file entries
556            * @param end the upper bound of the range of document library file entries (not inclusive)
557            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
558            * @param retrieveFromCache whether to retrieve from the finder cache
559            * @return the ordered range of matching document library file entries
560            */
561            public static List<DLFileEntry> findByGroupId(long groupId, int start,
562                    int end, OrderByComparator<DLFileEntry> orderByComparator,
563                    boolean retrieveFromCache) {
564                    return getPersistence()
565                                       .findByGroupId(groupId, start, end, orderByComparator,
566                            retrieveFromCache);
567            }
568    
569            /**
570            * Returns the first document library file entry in the ordered set where groupId = &#63;.
571            *
572            * @param groupId the group ID
573            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
574            * @return the first matching document library file entry
575            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
576            */
577            public static DLFileEntry findByGroupId_First(long groupId,
578                    OrderByComparator<DLFileEntry> orderByComparator)
579                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
580                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
581            }
582    
583            /**
584            * Returns the first document library file entry in the ordered set where groupId = &#63;.
585            *
586            * @param groupId the group ID
587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
588            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
589            */
590            public static DLFileEntry fetchByGroupId_First(long groupId,
591                    OrderByComparator<DLFileEntry> orderByComparator) {
592                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
593            }
594    
595            /**
596            * Returns the last document library file entry in the ordered set where groupId = &#63;.
597            *
598            * @param groupId the group ID
599            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
600            * @return the last matching document library file entry
601            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
602            */
603            public static DLFileEntry findByGroupId_Last(long groupId,
604                    OrderByComparator<DLFileEntry> orderByComparator)
605                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
606                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
607            }
608    
609            /**
610            * Returns the last document library file entry in the ordered set where groupId = &#63;.
611            *
612            * @param groupId the group ID
613            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
614            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
615            */
616            public static DLFileEntry fetchByGroupId_Last(long groupId,
617                    OrderByComparator<DLFileEntry> orderByComparator) {
618                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
619            }
620    
621            /**
622            * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = &#63;.
623            *
624            * @param fileEntryId the primary key of the current document library file entry
625            * @param groupId the group ID
626            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
627            * @return the previous, current, and next document library file entry
628            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
629            */
630            public static DLFileEntry[] findByGroupId_PrevAndNext(long fileEntryId,
631                    long groupId, OrderByComparator<DLFileEntry> orderByComparator)
632                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
633                    return getPersistence()
634                                       .findByGroupId_PrevAndNext(fileEntryId, groupId,
635                            orderByComparator);
636            }
637    
638            /**
639            * Returns all the document library file entries that the user has permission to view where groupId = &#63;.
640            *
641            * @param groupId the group ID
642            * @return the matching document library file entries that the user has permission to view
643            */
644            public static List<DLFileEntry> filterFindByGroupId(long groupId) {
645                    return getPersistence().filterFindByGroupId(groupId);
646            }
647    
648            /**
649            * Returns a range of all the document library file entries that the user has permission to view where groupId = &#63;.
650            *
651            * <p>
652            * 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 DLFileEntryModelImpl}. 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.
653            * </p>
654            *
655            * @param groupId the group ID
656            * @param start the lower bound of the range of document library file entries
657            * @param end the upper bound of the range of document library file entries (not inclusive)
658            * @return the range of matching document library file entries that the user has permission to view
659            */
660            public static List<DLFileEntry> filterFindByGroupId(long groupId,
661                    int start, int end) {
662                    return getPersistence().filterFindByGroupId(groupId, start, end);
663            }
664    
665            /**
666            * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = &#63;.
667            *
668            * <p>
669            * 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 DLFileEntryModelImpl}. 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.
670            * </p>
671            *
672            * @param groupId the group ID
673            * @param start the lower bound of the range of document library file entries
674            * @param end the upper bound of the range of document library file entries (not inclusive)
675            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
676            * @return the ordered range of matching document library file entries that the user has permission to view
677            */
678            public static List<DLFileEntry> filterFindByGroupId(long groupId,
679                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator) {
680                    return getPersistence()
681                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
682            }
683    
684            /**
685            * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = &#63;.
686            *
687            * @param fileEntryId the primary key of the current document library file entry
688            * @param groupId the group ID
689            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
690            * @return the previous, current, and next document library file entry
691            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
692            */
693            public static DLFileEntry[] filterFindByGroupId_PrevAndNext(
694                    long fileEntryId, long groupId,
695                    OrderByComparator<DLFileEntry> orderByComparator)
696                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
697                    return getPersistence()
698                                       .filterFindByGroupId_PrevAndNext(fileEntryId, groupId,
699                            orderByComparator);
700            }
701    
702            /**
703            * Removes all the document library file entries where groupId = &#63; from the database.
704            *
705            * @param groupId the group ID
706            */
707            public static void removeByGroupId(long groupId) {
708                    getPersistence().removeByGroupId(groupId);
709            }
710    
711            /**
712            * Returns the number of document library file entries where groupId = &#63;.
713            *
714            * @param groupId the group ID
715            * @return the number of matching document library file entries
716            */
717            public static int countByGroupId(long groupId) {
718                    return getPersistence().countByGroupId(groupId);
719            }
720    
721            /**
722            * Returns the number of document library file entries that the user has permission to view where groupId = &#63;.
723            *
724            * @param groupId the group ID
725            * @return the number of matching document library file entries that the user has permission to view
726            */
727            public static int filterCountByGroupId(long groupId) {
728                    return getPersistence().filterCountByGroupId(groupId);
729            }
730    
731            /**
732            * Returns all the document library file entries where companyId = &#63;.
733            *
734            * @param companyId the company ID
735            * @return the matching document library file entries
736            */
737            public static List<DLFileEntry> findByCompanyId(long companyId) {
738                    return getPersistence().findByCompanyId(companyId);
739            }
740    
741            /**
742            * Returns a range of all the document library file entries where companyId = &#63;.
743            *
744            * <p>
745            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
746            * </p>
747            *
748            * @param companyId the company ID
749            * @param start the lower bound of the range of document library file entries
750            * @param end the upper bound of the range of document library file entries (not inclusive)
751            * @return the range of matching document library file entries
752            */
753            public static List<DLFileEntry> findByCompanyId(long companyId, int start,
754                    int end) {
755                    return getPersistence().findByCompanyId(companyId, start, end);
756            }
757    
758            /**
759            * Returns an ordered range of all the document library file entries where companyId = &#63;.
760            *
761            * <p>
762            * 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 DLFileEntryModelImpl}. 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.
763            * </p>
764            *
765            * @param companyId the company ID
766            * @param start the lower bound of the range of document library file entries
767            * @param end the upper bound of the range of document library file entries (not inclusive)
768            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
769            * @return the ordered range of matching document library file entries
770            */
771            public static List<DLFileEntry> findByCompanyId(long companyId, int start,
772                    int end, OrderByComparator<DLFileEntry> orderByComparator) {
773                    return getPersistence()
774                                       .findByCompanyId(companyId, start, end, orderByComparator);
775            }
776    
777            /**
778            * Returns an ordered range of all the document library file entries where companyId = &#63;.
779            *
780            * <p>
781            * 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 DLFileEntryModelImpl}. 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.
782            * </p>
783            *
784            * @param companyId the company ID
785            * @param start the lower bound of the range of document library file entries
786            * @param end the upper bound of the range of document library file entries (not inclusive)
787            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
788            * @param retrieveFromCache whether to retrieve from the finder cache
789            * @return the ordered range of matching document library file entries
790            */
791            public static List<DLFileEntry> findByCompanyId(long companyId, int start,
792                    int end, OrderByComparator<DLFileEntry> orderByComparator,
793                    boolean retrieveFromCache) {
794                    return getPersistence()
795                                       .findByCompanyId(companyId, start, end, orderByComparator,
796                            retrieveFromCache);
797            }
798    
799            /**
800            * Returns the first document library file entry in the ordered set where companyId = &#63;.
801            *
802            * @param companyId the company ID
803            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
804            * @return the first matching document library file entry
805            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
806            */
807            public static DLFileEntry findByCompanyId_First(long companyId,
808                    OrderByComparator<DLFileEntry> orderByComparator)
809                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
810                    return getPersistence()
811                                       .findByCompanyId_First(companyId, orderByComparator);
812            }
813    
814            /**
815            * Returns the first document library file entry in the ordered set where companyId = &#63;.
816            *
817            * @param companyId the company ID
818            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
819            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
820            */
821            public static DLFileEntry fetchByCompanyId_First(long companyId,
822                    OrderByComparator<DLFileEntry> orderByComparator) {
823                    return getPersistence()
824                                       .fetchByCompanyId_First(companyId, orderByComparator);
825            }
826    
827            /**
828            * Returns the last document library file entry in the ordered set where companyId = &#63;.
829            *
830            * @param companyId the company ID
831            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
832            * @return the last matching document library file entry
833            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
834            */
835            public static DLFileEntry findByCompanyId_Last(long companyId,
836                    OrderByComparator<DLFileEntry> orderByComparator)
837                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
838                    return getPersistence()
839                                       .findByCompanyId_Last(companyId, orderByComparator);
840            }
841    
842            /**
843            * Returns the last document library file entry in the ordered set where companyId = &#63;.
844            *
845            * @param companyId the company ID
846            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
847            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
848            */
849            public static DLFileEntry fetchByCompanyId_Last(long companyId,
850                    OrderByComparator<DLFileEntry> orderByComparator) {
851                    return getPersistence()
852                                       .fetchByCompanyId_Last(companyId, orderByComparator);
853            }
854    
855            /**
856            * Returns the document library file entries before and after the current document library file entry in the ordered set where companyId = &#63;.
857            *
858            * @param fileEntryId the primary key of the current document library file entry
859            * @param companyId the company ID
860            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
861            * @return the previous, current, and next document library file entry
862            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
863            */
864            public static DLFileEntry[] findByCompanyId_PrevAndNext(long fileEntryId,
865                    long companyId, OrderByComparator<DLFileEntry> orderByComparator)
866                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
867                    return getPersistence()
868                                       .findByCompanyId_PrevAndNext(fileEntryId, companyId,
869                            orderByComparator);
870            }
871    
872            /**
873            * Removes all the document library file entries where companyId = &#63; from the database.
874            *
875            * @param companyId the company ID
876            */
877            public static void removeByCompanyId(long companyId) {
878                    getPersistence().removeByCompanyId(companyId);
879            }
880    
881            /**
882            * Returns the number of document library file entries where companyId = &#63;.
883            *
884            * @param companyId the company ID
885            * @return the number of matching document library file entries
886            */
887            public static int countByCompanyId(long companyId) {
888                    return getPersistence().countByCompanyId(companyId);
889            }
890    
891            /**
892            * Returns all the document library file entries where repositoryId = &#63;.
893            *
894            * @param repositoryId the repository ID
895            * @return the matching document library file entries
896            */
897            public static List<DLFileEntry> findByRepositoryId(long repositoryId) {
898                    return getPersistence().findByRepositoryId(repositoryId);
899            }
900    
901            /**
902            * Returns a range of all the document library file entries where repositoryId = &#63;.
903            *
904            * <p>
905            * 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 DLFileEntryModelImpl}. 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.
906            * </p>
907            *
908            * @param repositoryId the repository ID
909            * @param start the lower bound of the range of document library file entries
910            * @param end the upper bound of the range of document library file entries (not inclusive)
911            * @return the range of matching document library file entries
912            */
913            public static List<DLFileEntry> findByRepositoryId(long repositoryId,
914                    int start, int end) {
915                    return getPersistence().findByRepositoryId(repositoryId, start, end);
916            }
917    
918            /**
919            * Returns an ordered range of all the document library file entries where repositoryId = &#63;.
920            *
921            * <p>
922            * 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 DLFileEntryModelImpl}. 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.
923            * </p>
924            *
925            * @param repositoryId the repository ID
926            * @param start the lower bound of the range of document library file entries
927            * @param end the upper bound of the range of document library file entries (not inclusive)
928            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
929            * @return the ordered range of matching document library file entries
930            */
931            public static List<DLFileEntry> findByRepositoryId(long repositoryId,
932                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator) {
933                    return getPersistence()
934                                       .findByRepositoryId(repositoryId, start, end,
935                            orderByComparator);
936            }
937    
938            /**
939            * Returns an ordered range of all the document library file entries where repositoryId = &#63;.
940            *
941            * <p>
942            * 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 DLFileEntryModelImpl}. 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.
943            * </p>
944            *
945            * @param repositoryId the repository ID
946            * @param start the lower bound of the range of document library file entries
947            * @param end the upper bound of the range of document library file entries (not inclusive)
948            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
949            * @param retrieveFromCache whether to retrieve from the finder cache
950            * @return the ordered range of matching document library file entries
951            */
952            public static List<DLFileEntry> findByRepositoryId(long repositoryId,
953                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator,
954                    boolean retrieveFromCache) {
955                    return getPersistence()
956                                       .findByRepositoryId(repositoryId, start, end,
957                            orderByComparator, retrieveFromCache);
958            }
959    
960            /**
961            * Returns the first document library file entry in the ordered set where repositoryId = &#63;.
962            *
963            * @param repositoryId the repository ID
964            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
965            * @return the first matching document library file entry
966            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
967            */
968            public static DLFileEntry findByRepositoryId_First(long repositoryId,
969                    OrderByComparator<DLFileEntry> orderByComparator)
970                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
971                    return getPersistence()
972                                       .findByRepositoryId_First(repositoryId, orderByComparator);
973            }
974    
975            /**
976            * Returns the first document library file entry in the ordered set where repositoryId = &#63;.
977            *
978            * @param repositoryId the repository ID
979            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
980            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
981            */
982            public static DLFileEntry fetchByRepositoryId_First(long repositoryId,
983                    OrderByComparator<DLFileEntry> orderByComparator) {
984                    return getPersistence()
985                                       .fetchByRepositoryId_First(repositoryId, orderByComparator);
986            }
987    
988            /**
989            * Returns the last document library file entry in the ordered set where repositoryId = &#63;.
990            *
991            * @param repositoryId the repository ID
992            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
993            * @return the last matching document library file entry
994            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
995            */
996            public static DLFileEntry findByRepositoryId_Last(long repositoryId,
997                    OrderByComparator<DLFileEntry> orderByComparator)
998                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
999                    return getPersistence()
1000                                       .findByRepositoryId_Last(repositoryId, orderByComparator);
1001            }
1002    
1003            /**
1004            * Returns the last document library file entry in the ordered set where repositoryId = &#63;.
1005            *
1006            * @param repositoryId the repository ID
1007            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1008            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
1009            */
1010            public static DLFileEntry fetchByRepositoryId_Last(long repositoryId,
1011                    OrderByComparator<DLFileEntry> orderByComparator) {
1012                    return getPersistence()
1013                                       .fetchByRepositoryId_Last(repositoryId, orderByComparator);
1014            }
1015    
1016            /**
1017            * Returns the document library file entries before and after the current document library file entry in the ordered set where repositoryId = &#63;.
1018            *
1019            * @param fileEntryId the primary key of the current document library file entry
1020            * @param repositoryId the repository ID
1021            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1022            * @return the previous, current, and next document library file entry
1023            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
1024            */
1025            public static DLFileEntry[] findByRepositoryId_PrevAndNext(
1026                    long fileEntryId, long repositoryId,
1027                    OrderByComparator<DLFileEntry> orderByComparator)
1028                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1029                    return getPersistence()
1030                                       .findByRepositoryId_PrevAndNext(fileEntryId, repositoryId,
1031                            orderByComparator);
1032            }
1033    
1034            /**
1035            * Removes all the document library file entries where repositoryId = &#63; from the database.
1036            *
1037            * @param repositoryId the repository ID
1038            */
1039            public static void removeByRepositoryId(long repositoryId) {
1040                    getPersistence().removeByRepositoryId(repositoryId);
1041            }
1042    
1043            /**
1044            * Returns the number of document library file entries where repositoryId = &#63;.
1045            *
1046            * @param repositoryId the repository ID
1047            * @return the number of matching document library file entries
1048            */
1049            public static int countByRepositoryId(long repositoryId) {
1050                    return getPersistence().countByRepositoryId(repositoryId);
1051            }
1052    
1053            /**
1054            * Returns all the document library file entries where mimeType = &#63;.
1055            *
1056            * @param mimeType the mime type
1057            * @return the matching document library file entries
1058            */
1059            public static List<DLFileEntry> findByMimeType(java.lang.String mimeType) {
1060                    return getPersistence().findByMimeType(mimeType);
1061            }
1062    
1063            /**
1064            * Returns a range of all the document library file entries where mimeType = &#63;.
1065            *
1066            * <p>
1067            * 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 DLFileEntryModelImpl}. 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.
1068            * </p>
1069            *
1070            * @param mimeType the mime type
1071            * @param start the lower bound of the range of document library file entries
1072            * @param end the upper bound of the range of document library file entries (not inclusive)
1073            * @return the range of matching document library file entries
1074            */
1075            public static List<DLFileEntry> findByMimeType(java.lang.String mimeType,
1076                    int start, int end) {
1077                    return getPersistence().findByMimeType(mimeType, start, end);
1078            }
1079    
1080            /**
1081            * Returns an ordered range of all the document library file entries where mimeType = &#63;.
1082            *
1083            * <p>
1084            * 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 DLFileEntryModelImpl}. 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.
1085            * </p>
1086            *
1087            * @param mimeType the mime type
1088            * @param start the lower bound of the range of document library file entries
1089            * @param end the upper bound of the range of document library file entries (not inclusive)
1090            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1091            * @return the ordered range of matching document library file entries
1092            */
1093            public static List<DLFileEntry> findByMimeType(java.lang.String mimeType,
1094                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator) {
1095                    return getPersistence()
1096                                       .findByMimeType(mimeType, start, end, orderByComparator);
1097            }
1098    
1099            /**
1100            * Returns an ordered range of all the document library file entries where mimeType = &#63;.
1101            *
1102            * <p>
1103            * 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 DLFileEntryModelImpl}. 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.
1104            * </p>
1105            *
1106            * @param mimeType the mime type
1107            * @param start the lower bound of the range of document library file entries
1108            * @param end the upper bound of the range of document library file entries (not inclusive)
1109            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1110            * @param retrieveFromCache whether to retrieve from the finder cache
1111            * @return the ordered range of matching document library file entries
1112            */
1113            public static List<DLFileEntry> findByMimeType(java.lang.String mimeType,
1114                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator,
1115                    boolean retrieveFromCache) {
1116                    return getPersistence()
1117                                       .findByMimeType(mimeType, start, end, orderByComparator,
1118                            retrieveFromCache);
1119            }
1120    
1121            /**
1122            * Returns the first document library file entry in the ordered set where mimeType = &#63;.
1123            *
1124            * @param mimeType the mime type
1125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1126            * @return the first matching document library file entry
1127            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
1128            */
1129            public static DLFileEntry findByMimeType_First(java.lang.String mimeType,
1130                    OrderByComparator<DLFileEntry> orderByComparator)
1131                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1132                    return getPersistence().findByMimeType_First(mimeType, orderByComparator);
1133            }
1134    
1135            /**
1136            * Returns the first document library file entry in the ordered set where mimeType = &#63;.
1137            *
1138            * @param mimeType the mime type
1139            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1140            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
1141            */
1142            public static DLFileEntry fetchByMimeType_First(java.lang.String mimeType,
1143                    OrderByComparator<DLFileEntry> orderByComparator) {
1144                    return getPersistence()
1145                                       .fetchByMimeType_First(mimeType, orderByComparator);
1146            }
1147    
1148            /**
1149            * Returns the last document library file entry in the ordered set where mimeType = &#63;.
1150            *
1151            * @param mimeType the mime type
1152            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1153            * @return the last matching document library file entry
1154            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
1155            */
1156            public static DLFileEntry findByMimeType_Last(java.lang.String mimeType,
1157                    OrderByComparator<DLFileEntry> orderByComparator)
1158                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1159                    return getPersistence().findByMimeType_Last(mimeType, orderByComparator);
1160            }
1161    
1162            /**
1163            * Returns the last document library file entry in the ordered set where mimeType = &#63;.
1164            *
1165            * @param mimeType the mime type
1166            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1167            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
1168            */
1169            public static DLFileEntry fetchByMimeType_Last(java.lang.String mimeType,
1170                    OrderByComparator<DLFileEntry> orderByComparator) {
1171                    return getPersistence().fetchByMimeType_Last(mimeType, orderByComparator);
1172            }
1173    
1174            /**
1175            * Returns the document library file entries before and after the current document library file entry in the ordered set where mimeType = &#63;.
1176            *
1177            * @param fileEntryId the primary key of the current document library file entry
1178            * @param mimeType the mime type
1179            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1180            * @return the previous, current, and next document library file entry
1181            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
1182            */
1183            public static DLFileEntry[] findByMimeType_PrevAndNext(long fileEntryId,
1184                    java.lang.String mimeType,
1185                    OrderByComparator<DLFileEntry> orderByComparator)
1186                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1187                    return getPersistence()
1188                                       .findByMimeType_PrevAndNext(fileEntryId, mimeType,
1189                            orderByComparator);
1190            }
1191    
1192            /**
1193            * Removes all the document library file entries where mimeType = &#63; from the database.
1194            *
1195            * @param mimeType the mime type
1196            */
1197            public static void removeByMimeType(java.lang.String mimeType) {
1198                    getPersistence().removeByMimeType(mimeType);
1199            }
1200    
1201            /**
1202            * Returns the number of document library file entries where mimeType = &#63;.
1203            *
1204            * @param mimeType the mime type
1205            * @return the number of matching document library file entries
1206            */
1207            public static int countByMimeType(java.lang.String mimeType) {
1208                    return getPersistence().countByMimeType(mimeType);
1209            }
1210    
1211            /**
1212            * Returns all the document library file entries where fileEntryTypeId = &#63;.
1213            *
1214            * @param fileEntryTypeId the file entry type ID
1215            * @return the matching document library file entries
1216            */
1217            public static List<DLFileEntry> findByFileEntryTypeId(long fileEntryTypeId) {
1218                    return getPersistence().findByFileEntryTypeId(fileEntryTypeId);
1219            }
1220    
1221            /**
1222            * Returns a range of all the document library file entries where fileEntryTypeId = &#63;.
1223            *
1224            * <p>
1225            * 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 DLFileEntryModelImpl}. 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.
1226            * </p>
1227            *
1228            * @param fileEntryTypeId the file entry type ID
1229            * @param start the lower bound of the range of document library file entries
1230            * @param end the upper bound of the range of document library file entries (not inclusive)
1231            * @return the range of matching document library file entries
1232            */
1233            public static List<DLFileEntry> findByFileEntryTypeId(
1234                    long fileEntryTypeId, int start, int end) {
1235                    return getPersistence()
1236                                       .findByFileEntryTypeId(fileEntryTypeId, start, end);
1237            }
1238    
1239            /**
1240            * Returns an ordered range of all the document library file entries where fileEntryTypeId = &#63;.
1241            *
1242            * <p>
1243            * 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 DLFileEntryModelImpl}. 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.
1244            * </p>
1245            *
1246            * @param fileEntryTypeId the file entry type ID
1247            * @param start the lower bound of the range of document library file entries
1248            * @param end the upper bound of the range of document library file entries (not inclusive)
1249            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1250            * @return the ordered range of matching document library file entries
1251            */
1252            public static List<DLFileEntry> findByFileEntryTypeId(
1253                    long fileEntryTypeId, int start, int end,
1254                    OrderByComparator<DLFileEntry> orderByComparator) {
1255                    return getPersistence()
1256                                       .findByFileEntryTypeId(fileEntryTypeId, start, end,
1257                            orderByComparator);
1258            }
1259    
1260            /**
1261            * Returns an ordered range of all the document library file entries where fileEntryTypeId = &#63;.
1262            *
1263            * <p>
1264            * 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 DLFileEntryModelImpl}. 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.
1265            * </p>
1266            *
1267            * @param fileEntryTypeId the file entry type ID
1268            * @param start the lower bound of the range of document library file entries
1269            * @param end the upper bound of the range of document library file entries (not inclusive)
1270            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1271            * @param retrieveFromCache whether to retrieve from the finder cache
1272            * @return the ordered range of matching document library file entries
1273            */
1274            public static List<DLFileEntry> findByFileEntryTypeId(
1275                    long fileEntryTypeId, int start, int end,
1276                    OrderByComparator<DLFileEntry> orderByComparator,
1277                    boolean retrieveFromCache) {
1278                    return getPersistence()
1279                                       .findByFileEntryTypeId(fileEntryTypeId, start, end,
1280                            orderByComparator, retrieveFromCache);
1281            }
1282    
1283            /**
1284            * Returns the first document library file entry in the ordered set where fileEntryTypeId = &#63;.
1285            *
1286            * @param fileEntryTypeId the file entry type ID
1287            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1288            * @return the first matching document library file entry
1289            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
1290            */
1291            public static DLFileEntry findByFileEntryTypeId_First(
1292                    long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator)
1293                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1294                    return getPersistence()
1295                                       .findByFileEntryTypeId_First(fileEntryTypeId,
1296                            orderByComparator);
1297            }
1298    
1299            /**
1300            * Returns the first document library file entry in the ordered set where fileEntryTypeId = &#63;.
1301            *
1302            * @param fileEntryTypeId the file entry type ID
1303            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1304            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
1305            */
1306            public static DLFileEntry fetchByFileEntryTypeId_First(
1307                    long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) {
1308                    return getPersistence()
1309                                       .fetchByFileEntryTypeId_First(fileEntryTypeId,
1310                            orderByComparator);
1311            }
1312    
1313            /**
1314            * Returns the last document library file entry in the ordered set where fileEntryTypeId = &#63;.
1315            *
1316            * @param fileEntryTypeId the file entry type ID
1317            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1318            * @return the last matching document library file entry
1319            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
1320            */
1321            public static DLFileEntry findByFileEntryTypeId_Last(long fileEntryTypeId,
1322                    OrderByComparator<DLFileEntry> orderByComparator)
1323                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1324                    return getPersistence()
1325                                       .findByFileEntryTypeId_Last(fileEntryTypeId,
1326                            orderByComparator);
1327            }
1328    
1329            /**
1330            * Returns the last document library file entry in the ordered set where fileEntryTypeId = &#63;.
1331            *
1332            * @param fileEntryTypeId the file entry type ID
1333            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1334            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
1335            */
1336            public static DLFileEntry fetchByFileEntryTypeId_Last(
1337                    long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) {
1338                    return getPersistence()
1339                                       .fetchByFileEntryTypeId_Last(fileEntryTypeId,
1340                            orderByComparator);
1341            }
1342    
1343            /**
1344            * Returns the document library file entries before and after the current document library file entry in the ordered set where fileEntryTypeId = &#63;.
1345            *
1346            * @param fileEntryId the primary key of the current document library file entry
1347            * @param fileEntryTypeId the file entry type ID
1348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1349            * @return the previous, current, and next document library file entry
1350            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
1351            */
1352            public static DLFileEntry[] findByFileEntryTypeId_PrevAndNext(
1353                    long fileEntryId, long fileEntryTypeId,
1354                    OrderByComparator<DLFileEntry> orderByComparator)
1355                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1356                    return getPersistence()
1357                                       .findByFileEntryTypeId_PrevAndNext(fileEntryId,
1358                            fileEntryTypeId, orderByComparator);
1359            }
1360    
1361            /**
1362            * Removes all the document library file entries where fileEntryTypeId = &#63; from the database.
1363            *
1364            * @param fileEntryTypeId the file entry type ID
1365            */
1366            public static void removeByFileEntryTypeId(long fileEntryTypeId) {
1367                    getPersistence().removeByFileEntryTypeId(fileEntryTypeId);
1368            }
1369    
1370            /**
1371            * Returns the number of document library file entries where fileEntryTypeId = &#63;.
1372            *
1373            * @param fileEntryTypeId the file entry type ID
1374            * @return the number of matching document library file entries
1375            */
1376            public static int countByFileEntryTypeId(long fileEntryTypeId) {
1377                    return getPersistence().countByFileEntryTypeId(fileEntryTypeId);
1378            }
1379    
1380            /**
1381            * Returns all the document library file entries where groupId = &#63; and userId = &#63;.
1382            *
1383            * @param groupId the group ID
1384            * @param userId the user ID
1385            * @return the matching document library file entries
1386            */
1387            public static List<DLFileEntry> findByG_U(long groupId, long userId) {
1388                    return getPersistence().findByG_U(groupId, userId);
1389            }
1390    
1391            /**
1392            * Returns a range of all the document library file entries where groupId = &#63; and userId = &#63;.
1393            *
1394            * <p>
1395            * 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 DLFileEntryModelImpl}. 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.
1396            * </p>
1397            *
1398            * @param groupId the group ID
1399            * @param userId the user ID
1400            * @param start the lower bound of the range of document library file entries
1401            * @param end the upper bound of the range of document library file entries (not inclusive)
1402            * @return the range of matching document library file entries
1403            */
1404            public static List<DLFileEntry> findByG_U(long groupId, long userId,
1405                    int start, int end) {
1406                    return getPersistence().findByG_U(groupId, userId, start, end);
1407            }
1408    
1409            /**
1410            * Returns an ordered range of all the document library file entries where groupId = &#63; and userId = &#63;.
1411            *
1412            * <p>
1413            * 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 DLFileEntryModelImpl}. 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.
1414            * </p>
1415            *
1416            * @param groupId the group ID
1417            * @param userId the user ID
1418            * @param start the lower bound of the range of document library file entries
1419            * @param end the upper bound of the range of document library file entries (not inclusive)
1420            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1421            * @return the ordered range of matching document library file entries
1422            */
1423            public static List<DLFileEntry> findByG_U(long groupId, long userId,
1424                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator) {
1425                    return getPersistence()
1426                                       .findByG_U(groupId, userId, start, end, orderByComparator);
1427            }
1428    
1429            /**
1430            * Returns an ordered range of all the document library file entries where groupId = &#63; and userId = &#63;.
1431            *
1432            * <p>
1433            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1434            * </p>
1435            *
1436            * @param groupId the group ID
1437            * @param userId the user ID
1438            * @param start the lower bound of the range of document library file entries
1439            * @param end the upper bound of the range of document library file entries (not inclusive)
1440            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1441            * @param retrieveFromCache whether to retrieve from the finder cache
1442            * @return the ordered range of matching document library file entries
1443            */
1444            public static List<DLFileEntry> findByG_U(long groupId, long userId,
1445                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator,
1446                    boolean retrieveFromCache) {
1447                    return getPersistence()
1448                                       .findByG_U(groupId, userId, start, end, orderByComparator,
1449                            retrieveFromCache);
1450            }
1451    
1452            /**
1453            * Returns the first document library file entry in the ordered set where groupId = &#63; and userId = &#63;.
1454            *
1455            * @param groupId the group ID
1456            * @param userId the user ID
1457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1458            * @return the first matching document library file entry
1459            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
1460            */
1461            public static DLFileEntry findByG_U_First(long groupId, long userId,
1462                    OrderByComparator<DLFileEntry> orderByComparator)
1463                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1464                    return getPersistence()
1465                                       .findByG_U_First(groupId, userId, orderByComparator);
1466            }
1467    
1468            /**
1469            * Returns the first document library file entry in the ordered set where groupId = &#63; and userId = &#63;.
1470            *
1471            * @param groupId the group ID
1472            * @param userId the user ID
1473            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1474            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
1475            */
1476            public static DLFileEntry fetchByG_U_First(long groupId, long userId,
1477                    OrderByComparator<DLFileEntry> orderByComparator) {
1478                    return getPersistence()
1479                                       .fetchByG_U_First(groupId, userId, orderByComparator);
1480            }
1481    
1482            /**
1483            * Returns the last document library file entry in the ordered set where groupId = &#63; and userId = &#63;.
1484            *
1485            * @param groupId the group ID
1486            * @param userId the user ID
1487            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1488            * @return the last matching document library file entry
1489            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
1490            */
1491            public static DLFileEntry findByG_U_Last(long groupId, long userId,
1492                    OrderByComparator<DLFileEntry> orderByComparator)
1493                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1494                    return getPersistence()
1495                                       .findByG_U_Last(groupId, userId, orderByComparator);
1496            }
1497    
1498            /**
1499            * Returns the last document library file entry in the ordered set where groupId = &#63; and userId = &#63;.
1500            *
1501            * @param groupId the group ID
1502            * @param userId the user ID
1503            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1504            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
1505            */
1506            public static DLFileEntry fetchByG_U_Last(long groupId, long userId,
1507                    OrderByComparator<DLFileEntry> orderByComparator) {
1508                    return getPersistence()
1509                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
1510            }
1511    
1512            /**
1513            * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = &#63; and userId = &#63;.
1514            *
1515            * @param fileEntryId the primary key of the current document library file entry
1516            * @param groupId the group ID
1517            * @param userId the user ID
1518            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1519            * @return the previous, current, and next document library file entry
1520            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
1521            */
1522            public static DLFileEntry[] findByG_U_PrevAndNext(long fileEntryId,
1523                    long groupId, long userId,
1524                    OrderByComparator<DLFileEntry> orderByComparator)
1525                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1526                    return getPersistence()
1527                                       .findByG_U_PrevAndNext(fileEntryId, groupId, userId,
1528                            orderByComparator);
1529            }
1530    
1531            /**
1532            * Returns all the document library file entries that the user has permission to view where groupId = &#63; and userId = &#63;.
1533            *
1534            * @param groupId the group ID
1535            * @param userId the user ID
1536            * @return the matching document library file entries that the user has permission to view
1537            */
1538            public static List<DLFileEntry> filterFindByG_U(long groupId, long userId) {
1539                    return getPersistence().filterFindByG_U(groupId, userId);
1540            }
1541    
1542            /**
1543            * Returns a range of all the document library file entries that the user has permission to view where groupId = &#63; and userId = &#63;.
1544            *
1545            * <p>
1546            * 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 DLFileEntryModelImpl}. 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.
1547            * </p>
1548            *
1549            * @param groupId the group ID
1550            * @param userId the user ID
1551            * @param start the lower bound of the range of document library file entries
1552            * @param end the upper bound of the range of document library file entries (not inclusive)
1553            * @return the range of matching document library file entries that the user has permission to view
1554            */
1555            public static List<DLFileEntry> filterFindByG_U(long groupId, long userId,
1556                    int start, int end) {
1557                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
1558            }
1559    
1560            /**
1561            * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = &#63; and userId = &#63;.
1562            *
1563            * <p>
1564            * 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 DLFileEntryModelImpl}. 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.
1565            * </p>
1566            *
1567            * @param groupId the group ID
1568            * @param userId the user ID
1569            * @param start the lower bound of the range of document library file entries
1570            * @param end the upper bound of the range of document library file entries (not inclusive)
1571            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1572            * @return the ordered range of matching document library file entries that the user has permission to view
1573            */
1574            public static List<DLFileEntry> filterFindByG_U(long groupId, long userId,
1575                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator) {
1576                    return getPersistence()
1577                                       .filterFindByG_U(groupId, userId, start, end,
1578                            orderByComparator);
1579            }
1580    
1581            /**
1582            * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = &#63; and userId = &#63;.
1583            *
1584            * @param fileEntryId the primary key of the current document library file entry
1585            * @param groupId the group ID
1586            * @param userId the user ID
1587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1588            * @return the previous, current, and next document library file entry
1589            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
1590            */
1591            public static DLFileEntry[] filterFindByG_U_PrevAndNext(long fileEntryId,
1592                    long groupId, long userId,
1593                    OrderByComparator<DLFileEntry> orderByComparator)
1594                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1595                    return getPersistence()
1596                                       .filterFindByG_U_PrevAndNext(fileEntryId, groupId, userId,
1597                            orderByComparator);
1598            }
1599    
1600            /**
1601            * Removes all the document library file entries where groupId = &#63; and userId = &#63; from the database.
1602            *
1603            * @param groupId the group ID
1604            * @param userId the user ID
1605            */
1606            public static void removeByG_U(long groupId, long userId) {
1607                    getPersistence().removeByG_U(groupId, userId);
1608            }
1609    
1610            /**
1611            * Returns the number of document library file entries where groupId = &#63; and userId = &#63;.
1612            *
1613            * @param groupId the group ID
1614            * @param userId the user ID
1615            * @return the number of matching document library file entries
1616            */
1617            public static int countByG_U(long groupId, long userId) {
1618                    return getPersistence().countByG_U(groupId, userId);
1619            }
1620    
1621            /**
1622            * Returns the number of document library file entries that the user has permission to view where groupId = &#63; and userId = &#63;.
1623            *
1624            * @param groupId the group ID
1625            * @param userId the user ID
1626            * @return the number of matching document library file entries that the user has permission to view
1627            */
1628            public static int filterCountByG_U(long groupId, long userId) {
1629                    return getPersistence().filterCountByG_U(groupId, userId);
1630            }
1631    
1632            /**
1633            * Returns all the document library file entries where groupId = &#63; and folderId = &#63;.
1634            *
1635            * @param groupId the group ID
1636            * @param folderId the folder ID
1637            * @return the matching document library file entries
1638            */
1639            public static List<DLFileEntry> findByG_F(long groupId, long folderId) {
1640                    return getPersistence().findByG_F(groupId, folderId);
1641            }
1642    
1643            /**
1644            * Returns a range of all the document library file entries where groupId = &#63; and folderId = &#63;.
1645            *
1646            * <p>
1647            * 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 DLFileEntryModelImpl}. 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.
1648            * </p>
1649            *
1650            * @param groupId the group ID
1651            * @param folderId the folder ID
1652            * @param start the lower bound of the range of document library file entries
1653            * @param end the upper bound of the range of document library file entries (not inclusive)
1654            * @return the range of matching document library file entries
1655            */
1656            public static List<DLFileEntry> findByG_F(long groupId, long folderId,
1657                    int start, int end) {
1658                    return getPersistence().findByG_F(groupId, folderId, start, end);
1659            }
1660    
1661            /**
1662            * Returns an ordered range of all the document library file entries where groupId = &#63; and folderId = &#63;.
1663            *
1664            * <p>
1665            * 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 DLFileEntryModelImpl}. 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.
1666            * </p>
1667            *
1668            * @param groupId the group ID
1669            * @param folderId the folder ID
1670            * @param start the lower bound of the range of document library file entries
1671            * @param end the upper bound of the range of document library file entries (not inclusive)
1672            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1673            * @return the ordered range of matching document library file entries
1674            */
1675            public static List<DLFileEntry> findByG_F(long groupId, long folderId,
1676                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator) {
1677                    return getPersistence()
1678                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
1679            }
1680    
1681            /**
1682            * Returns an ordered range of all the document library file entries where groupId = &#63; and folderId = &#63;.
1683            *
1684            * <p>
1685            * 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 DLFileEntryModelImpl}. 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.
1686            * </p>
1687            *
1688            * @param groupId the group ID
1689            * @param folderId the folder ID
1690            * @param start the lower bound of the range of document library file entries
1691            * @param end the upper bound of the range of document library file entries (not inclusive)
1692            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1693            * @param retrieveFromCache whether to retrieve from the finder cache
1694            * @return the ordered range of matching document library file entries
1695            */
1696            public static List<DLFileEntry> findByG_F(long groupId, long folderId,
1697                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator,
1698                    boolean retrieveFromCache) {
1699                    return getPersistence()
1700                                       .findByG_F(groupId, folderId, start, end, orderByComparator,
1701                            retrieveFromCache);
1702            }
1703    
1704            /**
1705            * Returns the first document library file entry in the ordered set where groupId = &#63; and folderId = &#63;.
1706            *
1707            * @param groupId the group ID
1708            * @param folderId the folder ID
1709            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1710            * @return the first matching document library file entry
1711            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
1712            */
1713            public static DLFileEntry findByG_F_First(long groupId, long folderId,
1714                    OrderByComparator<DLFileEntry> orderByComparator)
1715                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1716                    return getPersistence()
1717                                       .findByG_F_First(groupId, folderId, orderByComparator);
1718            }
1719    
1720            /**
1721            * Returns the first document library file entry in the ordered set where groupId = &#63; and folderId = &#63;.
1722            *
1723            * @param groupId the group ID
1724            * @param folderId the folder ID
1725            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1726            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
1727            */
1728            public static DLFileEntry fetchByG_F_First(long groupId, long folderId,
1729                    OrderByComparator<DLFileEntry> orderByComparator) {
1730                    return getPersistence()
1731                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
1732            }
1733    
1734            /**
1735            * Returns the last document library file entry in the ordered set where groupId = &#63; and folderId = &#63;.
1736            *
1737            * @param groupId the group ID
1738            * @param folderId the folder ID
1739            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1740            * @return the last matching document library file entry
1741            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
1742            */
1743            public static DLFileEntry findByG_F_Last(long groupId, long folderId,
1744                    OrderByComparator<DLFileEntry> orderByComparator)
1745                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1746                    return getPersistence()
1747                                       .findByG_F_Last(groupId, folderId, orderByComparator);
1748            }
1749    
1750            /**
1751            * Returns the last document library file entry in the ordered set where groupId = &#63; and folderId = &#63;.
1752            *
1753            * @param groupId the group ID
1754            * @param folderId the folder ID
1755            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1756            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
1757            */
1758            public static DLFileEntry fetchByG_F_Last(long groupId, long folderId,
1759                    OrderByComparator<DLFileEntry> orderByComparator) {
1760                    return getPersistence()
1761                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
1762            }
1763    
1764            /**
1765            * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = &#63; and folderId = &#63;.
1766            *
1767            * @param fileEntryId the primary key of the current document library file entry
1768            * @param groupId the group ID
1769            * @param folderId the folder ID
1770            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1771            * @return the previous, current, and next document library file entry
1772            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
1773            */
1774            public static DLFileEntry[] findByG_F_PrevAndNext(long fileEntryId,
1775                    long groupId, long folderId,
1776                    OrderByComparator<DLFileEntry> orderByComparator)
1777                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1778                    return getPersistence()
1779                                       .findByG_F_PrevAndNext(fileEntryId, groupId, folderId,
1780                            orderByComparator);
1781            }
1782    
1783            /**
1784            * Returns all the document library file entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1785            *
1786            * @param groupId the group ID
1787            * @param folderId the folder ID
1788            * @return the matching document library file entries that the user has permission to view
1789            */
1790            public static List<DLFileEntry> filterFindByG_F(long groupId, long folderId) {
1791                    return getPersistence().filterFindByG_F(groupId, folderId);
1792            }
1793    
1794            /**
1795            * Returns a range of all the document library file entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1796            *
1797            * <p>
1798            * 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 DLFileEntryModelImpl}. 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.
1799            * </p>
1800            *
1801            * @param groupId the group ID
1802            * @param folderId the folder ID
1803            * @param start the lower bound of the range of document library file entries
1804            * @param end the upper bound of the range of document library file entries (not inclusive)
1805            * @return the range of matching document library file entries that the user has permission to view
1806            */
1807            public static List<DLFileEntry> filterFindByG_F(long groupId,
1808                    long folderId, int start, int end) {
1809                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
1810            }
1811    
1812            /**
1813            * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = &#63; and folderId = &#63;.
1814            *
1815            * <p>
1816            * 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 DLFileEntryModelImpl}. 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.
1817            * </p>
1818            *
1819            * @param groupId the group ID
1820            * @param folderId the folder ID
1821            * @param start the lower bound of the range of document library file entries
1822            * @param end the upper bound of the range of document library file entries (not inclusive)
1823            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1824            * @return the ordered range of matching document library file entries that the user has permission to view
1825            */
1826            public static List<DLFileEntry> filterFindByG_F(long groupId,
1827                    long folderId, int start, int end,
1828                    OrderByComparator<DLFileEntry> orderByComparator) {
1829                    return getPersistence()
1830                                       .filterFindByG_F(groupId, folderId, start, end,
1831                            orderByComparator);
1832            }
1833    
1834            /**
1835            * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1836            *
1837            * @param fileEntryId the primary key of the current document library file entry
1838            * @param groupId the group ID
1839            * @param folderId the folder ID
1840            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1841            * @return the previous, current, and next document library file entry
1842            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
1843            */
1844            public static DLFileEntry[] filterFindByG_F_PrevAndNext(long fileEntryId,
1845                    long groupId, long folderId,
1846                    OrderByComparator<DLFileEntry> orderByComparator)
1847                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
1848                    return getPersistence()
1849                                       .filterFindByG_F_PrevAndNext(fileEntryId, groupId, folderId,
1850                            orderByComparator);
1851            }
1852    
1853            /**
1854            * Returns all the document library file entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1855            *
1856            * @param groupId the group ID
1857            * @param folderIds the folder IDs
1858            * @return the matching document library file entries that the user has permission to view
1859            */
1860            public static List<DLFileEntry> filterFindByG_F(long groupId,
1861                    long[] folderIds) {
1862                    return getPersistence().filterFindByG_F(groupId, folderIds);
1863            }
1864    
1865            /**
1866            * Returns a range of all the document library file entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1867            *
1868            * <p>
1869            * 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 DLFileEntryModelImpl}. 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.
1870            * </p>
1871            *
1872            * @param groupId the group ID
1873            * @param folderIds the folder IDs
1874            * @param start the lower bound of the range of document library file entries
1875            * @param end the upper bound of the range of document library file entries (not inclusive)
1876            * @return the range of matching document library file entries that the user has permission to view
1877            */
1878            public static List<DLFileEntry> filterFindByG_F(long groupId,
1879                    long[] folderIds, int start, int end) {
1880                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
1881            }
1882    
1883            /**
1884            * Returns an ordered range of all the document library file entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1885            *
1886            * <p>
1887            * 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 DLFileEntryModelImpl}. 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.
1888            * </p>
1889            *
1890            * @param groupId the group ID
1891            * @param folderIds the folder IDs
1892            * @param start the lower bound of the range of document library file entries
1893            * @param end the upper bound of the range of document library file entries (not inclusive)
1894            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1895            * @return the ordered range of matching document library file entries that the user has permission to view
1896            */
1897            public static List<DLFileEntry> filterFindByG_F(long groupId,
1898                    long[] folderIds, int start, int end,
1899                    OrderByComparator<DLFileEntry> orderByComparator) {
1900                    return getPersistence()
1901                                       .filterFindByG_F(groupId, folderIds, start, end,
1902                            orderByComparator);
1903            }
1904    
1905            /**
1906            * Returns all the document library file entries where groupId = &#63; and folderId = any &#63;.
1907            *
1908            * <p>
1909            * 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 DLFileEntryModelImpl}. 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.
1910            * </p>
1911            *
1912            * @param groupId the group ID
1913            * @param folderIds the folder IDs
1914            * @return the matching document library file entries
1915            */
1916            public static List<DLFileEntry> findByG_F(long groupId, long[] folderIds) {
1917                    return getPersistence().findByG_F(groupId, folderIds);
1918            }
1919    
1920            /**
1921            * Returns a range of all the document library file entries where groupId = &#63; and folderId = any &#63;.
1922            *
1923            * <p>
1924            * 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 DLFileEntryModelImpl}. 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.
1925            * </p>
1926            *
1927            * @param groupId the group ID
1928            * @param folderIds the folder IDs
1929            * @param start the lower bound of the range of document library file entries
1930            * @param end the upper bound of the range of document library file entries (not inclusive)
1931            * @return the range of matching document library file entries
1932            */
1933            public static List<DLFileEntry> findByG_F(long groupId, long[] folderIds,
1934                    int start, int end) {
1935                    return getPersistence().findByG_F(groupId, folderIds, start, end);
1936            }
1937    
1938            /**
1939            * Returns an ordered range of all the document library file entries where groupId = &#63; and folderId = any &#63;.
1940            *
1941            * <p>
1942            * 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 DLFileEntryModelImpl}. 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.
1943            * </p>
1944            *
1945            * @param groupId the group ID
1946            * @param folderIds the folder IDs
1947            * @param start the lower bound of the range of document library file entries
1948            * @param end the upper bound of the range of document library file entries (not inclusive)
1949            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1950            * @return the ordered range of matching document library file entries
1951            */
1952            public static List<DLFileEntry> findByG_F(long groupId, long[] folderIds,
1953                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator) {
1954                    return getPersistence()
1955                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
1956            }
1957    
1958            /**
1959            * Returns an ordered range of all the document library file entries where groupId = &#63; and folderId = &#63;, optionally using the finder cache.
1960            *
1961            * <p>
1962            * 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 DLFileEntryModelImpl}. 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.
1963            * </p>
1964            *
1965            * @param groupId the group ID
1966            * @param folderId the folder ID
1967            * @param start the lower bound of the range of document library file entries
1968            * @param end the upper bound of the range of document library file entries (not inclusive)
1969            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1970            * @param retrieveFromCache whether to retrieve from the finder cache
1971            * @return the ordered range of matching document library file entries
1972            */
1973            public static List<DLFileEntry> findByG_F(long groupId, long[] folderIds,
1974                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator,
1975                    boolean retrieveFromCache) {
1976                    return getPersistence()
1977                                       .findByG_F(groupId, folderIds, start, end,
1978                            orderByComparator, retrieveFromCache);
1979            }
1980    
1981            /**
1982            * Removes all the document library file entries where groupId = &#63; and folderId = &#63; from the database.
1983            *
1984            * @param groupId the group ID
1985            * @param folderId the folder ID
1986            */
1987            public static void removeByG_F(long groupId, long folderId) {
1988                    getPersistence().removeByG_F(groupId, folderId);
1989            }
1990    
1991            /**
1992            * Returns the number of document library file entries where groupId = &#63; and folderId = &#63;.
1993            *
1994            * @param groupId the group ID
1995            * @param folderId the folder ID
1996            * @return the number of matching document library file entries
1997            */
1998            public static int countByG_F(long groupId, long folderId) {
1999                    return getPersistence().countByG_F(groupId, folderId);
2000            }
2001    
2002            /**
2003            * Returns the number of document library file entries where groupId = &#63; and folderId = any &#63;.
2004            *
2005            * @param groupId the group ID
2006            * @param folderIds the folder IDs
2007            * @return the number of matching document library file entries
2008            */
2009            public static int countByG_F(long groupId, long[] folderIds) {
2010                    return getPersistence().countByG_F(groupId, folderIds);
2011            }
2012    
2013            /**
2014            * Returns the number of document library file entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
2015            *
2016            * @param groupId the group ID
2017            * @param folderId the folder ID
2018            * @return the number of matching document library file entries that the user has permission to view
2019            */
2020            public static int filterCountByG_F(long groupId, long folderId) {
2021                    return getPersistence().filterCountByG_F(groupId, folderId);
2022            }
2023    
2024            /**
2025            * Returns the number of document library file entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2026            *
2027            * @param groupId the group ID
2028            * @param folderIds the folder IDs
2029            * @return the number of matching document library file entries that the user has permission to view
2030            */
2031            public static int filterCountByG_F(long groupId, long[] folderIds) {
2032                    return getPersistence().filterCountByG_F(groupId, folderIds);
2033            }
2034    
2035            /**
2036            * Returns all the document library file entries where repositoryId = &#63; and folderId = &#63;.
2037            *
2038            * @param repositoryId the repository ID
2039            * @param folderId the folder ID
2040            * @return the matching document library file entries
2041            */
2042            public static List<DLFileEntry> findByR_F(long repositoryId, long folderId) {
2043                    return getPersistence().findByR_F(repositoryId, folderId);
2044            }
2045    
2046            /**
2047            * Returns a range of all the document library file entries where repositoryId = &#63; and folderId = &#63;.
2048            *
2049            * <p>
2050            * 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 DLFileEntryModelImpl}. 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.
2051            * </p>
2052            *
2053            * @param repositoryId the repository ID
2054            * @param folderId the folder ID
2055            * @param start the lower bound of the range of document library file entries
2056            * @param end the upper bound of the range of document library file entries (not inclusive)
2057            * @return the range of matching document library file entries
2058            */
2059            public static List<DLFileEntry> findByR_F(long repositoryId, long folderId,
2060                    int start, int end) {
2061                    return getPersistence().findByR_F(repositoryId, folderId, start, end);
2062            }
2063    
2064            /**
2065            * Returns an ordered range of all the document library file entries where repositoryId = &#63; and folderId = &#63;.
2066            *
2067            * <p>
2068            * 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 DLFileEntryModelImpl}. 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.
2069            * </p>
2070            *
2071            * @param repositoryId the repository ID
2072            * @param folderId the folder ID
2073            * @param start the lower bound of the range of document library file entries
2074            * @param end the upper bound of the range of document library file entries (not inclusive)
2075            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2076            * @return the ordered range of matching document library file entries
2077            */
2078            public static List<DLFileEntry> findByR_F(long repositoryId, long folderId,
2079                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator) {
2080                    return getPersistence()
2081                                       .findByR_F(repositoryId, folderId, start, end,
2082                            orderByComparator);
2083            }
2084    
2085            /**
2086            * Returns an ordered range of all the document library file entries where repositoryId = &#63; and folderId = &#63;.
2087            *
2088            * <p>
2089            * 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 DLFileEntryModelImpl}. 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.
2090            * </p>
2091            *
2092            * @param repositoryId the repository ID
2093            * @param folderId the folder ID
2094            * @param start the lower bound of the range of document library file entries
2095            * @param end the upper bound of the range of document library file entries (not inclusive)
2096            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2097            * @param retrieveFromCache whether to retrieve from the finder cache
2098            * @return the ordered range of matching document library file entries
2099            */
2100            public static List<DLFileEntry> findByR_F(long repositoryId, long folderId,
2101                    int start, int end, OrderByComparator<DLFileEntry> orderByComparator,
2102                    boolean retrieveFromCache) {
2103                    return getPersistence()
2104                                       .findByR_F(repositoryId, folderId, start, end,
2105                            orderByComparator, retrieveFromCache);
2106            }
2107    
2108            /**
2109            * Returns the first document library file entry in the ordered set where repositoryId = &#63; and folderId = &#63;.
2110            *
2111            * @param repositoryId the repository ID
2112            * @param folderId the folder ID
2113            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2114            * @return the first matching document library file entry
2115            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
2116            */
2117            public static DLFileEntry findByR_F_First(long repositoryId, long folderId,
2118                    OrderByComparator<DLFileEntry> orderByComparator)
2119                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2120                    return getPersistence()
2121                                       .findByR_F_First(repositoryId, folderId, orderByComparator);
2122            }
2123    
2124            /**
2125            * Returns the first document library file entry in the ordered set where repositoryId = &#63; and folderId = &#63;.
2126            *
2127            * @param repositoryId the repository ID
2128            * @param folderId the folder ID
2129            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2130            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2131            */
2132            public static DLFileEntry fetchByR_F_First(long repositoryId,
2133                    long folderId, OrderByComparator<DLFileEntry> orderByComparator) {
2134                    return getPersistence()
2135                                       .fetchByR_F_First(repositoryId, folderId, orderByComparator);
2136            }
2137    
2138            /**
2139            * Returns the last document library file entry in the ordered set where repositoryId = &#63; and folderId = &#63;.
2140            *
2141            * @param repositoryId the repository ID
2142            * @param folderId the folder ID
2143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2144            * @return the last matching document library file entry
2145            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
2146            */
2147            public static DLFileEntry findByR_F_Last(long repositoryId, long folderId,
2148                    OrderByComparator<DLFileEntry> orderByComparator)
2149                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2150                    return getPersistence()
2151                                       .findByR_F_Last(repositoryId, folderId, orderByComparator);
2152            }
2153    
2154            /**
2155            * Returns the last document library file entry in the ordered set where repositoryId = &#63; and folderId = &#63;.
2156            *
2157            * @param repositoryId the repository ID
2158            * @param folderId the folder ID
2159            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2160            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2161            */
2162            public static DLFileEntry fetchByR_F_Last(long repositoryId, long folderId,
2163                    OrderByComparator<DLFileEntry> orderByComparator) {
2164                    return getPersistence()
2165                                       .fetchByR_F_Last(repositoryId, folderId, orderByComparator);
2166            }
2167    
2168            /**
2169            * Returns the document library file entries before and after the current document library file entry in the ordered set where repositoryId = &#63; and folderId = &#63;.
2170            *
2171            * @param fileEntryId the primary key of the current document library file entry
2172            * @param repositoryId the repository ID
2173            * @param folderId the folder ID
2174            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2175            * @return the previous, current, and next document library file entry
2176            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
2177            */
2178            public static DLFileEntry[] findByR_F_PrevAndNext(long fileEntryId,
2179                    long repositoryId, long folderId,
2180                    OrderByComparator<DLFileEntry> orderByComparator)
2181                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2182                    return getPersistence()
2183                                       .findByR_F_PrevAndNext(fileEntryId, repositoryId, folderId,
2184                            orderByComparator);
2185            }
2186    
2187            /**
2188            * Removes all the document library file entries where repositoryId = &#63; and folderId = &#63; from the database.
2189            *
2190            * @param repositoryId the repository ID
2191            * @param folderId the folder ID
2192            */
2193            public static void removeByR_F(long repositoryId, long folderId) {
2194                    getPersistence().removeByR_F(repositoryId, folderId);
2195            }
2196    
2197            /**
2198            * Returns the number of document library file entries where repositoryId = &#63; and folderId = &#63;.
2199            *
2200            * @param repositoryId the repository ID
2201            * @param folderId the folder ID
2202            * @return the number of matching document library file entries
2203            */
2204            public static int countByR_F(long repositoryId, long folderId) {
2205                    return getPersistence().countByR_F(repositoryId, folderId);
2206            }
2207    
2208            /**
2209            * Returns all the document library file entries where folderId = &#63; and name = &#63;.
2210            *
2211            * @param folderId the folder ID
2212            * @param name the name
2213            * @return the matching document library file entries
2214            */
2215            public static List<DLFileEntry> findByF_N(long folderId,
2216                    java.lang.String name) {
2217                    return getPersistence().findByF_N(folderId, name);
2218            }
2219    
2220            /**
2221            * Returns a range of all the document library file entries where folderId = &#63; and name = &#63;.
2222            *
2223            * <p>
2224            * 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 DLFileEntryModelImpl}. 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.
2225            * </p>
2226            *
2227            * @param folderId the folder ID
2228            * @param name the name
2229            * @param start the lower bound of the range of document library file entries
2230            * @param end the upper bound of the range of document library file entries (not inclusive)
2231            * @return the range of matching document library file entries
2232            */
2233            public static List<DLFileEntry> findByF_N(long folderId,
2234                    java.lang.String name, int start, int end) {
2235                    return getPersistence().findByF_N(folderId, name, start, end);
2236            }
2237    
2238            /**
2239            * Returns an ordered range of all the document library file entries where folderId = &#63; and name = &#63;.
2240            *
2241            * <p>
2242            * 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 DLFileEntryModelImpl}. 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.
2243            * </p>
2244            *
2245            * @param folderId the folder ID
2246            * @param name the name
2247            * @param start the lower bound of the range of document library file entries
2248            * @param end the upper bound of the range of document library file entries (not inclusive)
2249            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2250            * @return the ordered range of matching document library file entries
2251            */
2252            public static List<DLFileEntry> findByF_N(long folderId,
2253                    java.lang.String name, int start, int end,
2254                    OrderByComparator<DLFileEntry> orderByComparator) {
2255                    return getPersistence()
2256                                       .findByF_N(folderId, name, start, end, orderByComparator);
2257            }
2258    
2259            /**
2260            * Returns an ordered range of all the document library file entries where folderId = &#63; and name = &#63;.
2261            *
2262            * <p>
2263            * 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 DLFileEntryModelImpl}. 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.
2264            * </p>
2265            *
2266            * @param folderId the folder ID
2267            * @param name the name
2268            * @param start the lower bound of the range of document library file entries
2269            * @param end the upper bound of the range of document library file entries (not inclusive)
2270            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2271            * @param retrieveFromCache whether to retrieve from the finder cache
2272            * @return the ordered range of matching document library file entries
2273            */
2274            public static List<DLFileEntry> findByF_N(long folderId,
2275                    java.lang.String name, int start, int end,
2276                    OrderByComparator<DLFileEntry> orderByComparator,
2277                    boolean retrieveFromCache) {
2278                    return getPersistence()
2279                                       .findByF_N(folderId, name, start, end, orderByComparator,
2280                            retrieveFromCache);
2281            }
2282    
2283            /**
2284            * Returns the first document library file entry in the ordered set where folderId = &#63; and name = &#63;.
2285            *
2286            * @param folderId the folder ID
2287            * @param name the name
2288            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2289            * @return the first matching document library file entry
2290            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
2291            */
2292            public static DLFileEntry findByF_N_First(long folderId,
2293                    java.lang.String name, OrderByComparator<DLFileEntry> orderByComparator)
2294                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2295                    return getPersistence()
2296                                       .findByF_N_First(folderId, name, orderByComparator);
2297            }
2298    
2299            /**
2300            * Returns the first document library file entry in the ordered set where folderId = &#63; and name = &#63;.
2301            *
2302            * @param folderId the folder ID
2303            * @param name the name
2304            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2305            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2306            */
2307            public static DLFileEntry fetchByF_N_First(long folderId,
2308                    java.lang.String name, OrderByComparator<DLFileEntry> orderByComparator) {
2309                    return getPersistence()
2310                                       .fetchByF_N_First(folderId, name, orderByComparator);
2311            }
2312    
2313            /**
2314            * Returns the last document library file entry in the ordered set where folderId = &#63; and name = &#63;.
2315            *
2316            * @param folderId the folder ID
2317            * @param name the name
2318            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2319            * @return the last matching document library file entry
2320            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
2321            */
2322            public static DLFileEntry findByF_N_Last(long folderId,
2323                    java.lang.String name, OrderByComparator<DLFileEntry> orderByComparator)
2324                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2325                    return getPersistence().findByF_N_Last(folderId, name, orderByComparator);
2326            }
2327    
2328            /**
2329            * Returns the last document library file entry in the ordered set where folderId = &#63; and name = &#63;.
2330            *
2331            * @param folderId the folder ID
2332            * @param name the name
2333            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2334            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2335            */
2336            public static DLFileEntry fetchByF_N_Last(long folderId,
2337                    java.lang.String name, OrderByComparator<DLFileEntry> orderByComparator) {
2338                    return getPersistence()
2339                                       .fetchByF_N_Last(folderId, name, orderByComparator);
2340            }
2341    
2342            /**
2343            * Returns the document library file entries before and after the current document library file entry in the ordered set where folderId = &#63; and name = &#63;.
2344            *
2345            * @param fileEntryId the primary key of the current document library file entry
2346            * @param folderId the folder ID
2347            * @param name the name
2348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2349            * @return the previous, current, and next document library file entry
2350            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
2351            */
2352            public static DLFileEntry[] findByF_N_PrevAndNext(long fileEntryId,
2353                    long folderId, java.lang.String name,
2354                    OrderByComparator<DLFileEntry> orderByComparator)
2355                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2356                    return getPersistence()
2357                                       .findByF_N_PrevAndNext(fileEntryId, folderId, name,
2358                            orderByComparator);
2359            }
2360    
2361            /**
2362            * Removes all the document library file entries where folderId = &#63; and name = &#63; from the database.
2363            *
2364            * @param folderId the folder ID
2365            * @param name the name
2366            */
2367            public static void removeByF_N(long folderId, java.lang.String name) {
2368                    getPersistence().removeByF_N(folderId, name);
2369            }
2370    
2371            /**
2372            * Returns the number of document library file entries where folderId = &#63; and name = &#63;.
2373            *
2374            * @param folderId the folder ID
2375            * @param name the name
2376            * @return the number of matching document library file entries
2377            */
2378            public static int countByF_N(long folderId, java.lang.String name) {
2379                    return getPersistence().countByF_N(folderId, name);
2380            }
2381    
2382            /**
2383            * Returns all the document library file entries where groupId = &#63; and userId = &#63; and folderId = &#63;.
2384            *
2385            * @param groupId the group ID
2386            * @param userId the user ID
2387            * @param folderId the folder ID
2388            * @return the matching document library file entries
2389            */
2390            public static List<DLFileEntry> findByG_U_F(long groupId, long userId,
2391                    long folderId) {
2392                    return getPersistence().findByG_U_F(groupId, userId, folderId);
2393            }
2394    
2395            /**
2396            * Returns a range of all the document library file entries where groupId = &#63; and userId = &#63; and folderId = &#63;.
2397            *
2398            * <p>
2399            * 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 DLFileEntryModelImpl}. 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.
2400            * </p>
2401            *
2402            * @param groupId the group ID
2403            * @param userId the user ID
2404            * @param folderId the folder ID
2405            * @param start the lower bound of the range of document library file entries
2406            * @param end the upper bound of the range of document library file entries (not inclusive)
2407            * @return the range of matching document library file entries
2408            */
2409            public static List<DLFileEntry> findByG_U_F(long groupId, long userId,
2410                    long folderId, int start, int end) {
2411                    return getPersistence()
2412                                       .findByG_U_F(groupId, userId, folderId, start, end);
2413            }
2414    
2415            /**
2416            * Returns an ordered range of all the document library file entries where groupId = &#63; and userId = &#63; and folderId = &#63;.
2417            *
2418            * <p>
2419            * 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 DLFileEntryModelImpl}. 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.
2420            * </p>
2421            *
2422            * @param groupId the group ID
2423            * @param userId the user ID
2424            * @param folderId the folder ID
2425            * @param start the lower bound of the range of document library file entries
2426            * @param end the upper bound of the range of document library file entries (not inclusive)
2427            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2428            * @return the ordered range of matching document library file entries
2429            */
2430            public static List<DLFileEntry> findByG_U_F(long groupId, long userId,
2431                    long folderId, int start, int end,
2432                    OrderByComparator<DLFileEntry> orderByComparator) {
2433                    return getPersistence()
2434                                       .findByG_U_F(groupId, userId, folderId, start, end,
2435                            orderByComparator);
2436            }
2437    
2438            /**
2439            * Returns an ordered range of all the document library file entries where groupId = &#63; and userId = &#63; and folderId = &#63;.
2440            *
2441            * <p>
2442            * 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 DLFileEntryModelImpl}. 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.
2443            * </p>
2444            *
2445            * @param groupId the group ID
2446            * @param userId the user ID
2447            * @param folderId the folder ID
2448            * @param start the lower bound of the range of document library file entries
2449            * @param end the upper bound of the range of document library file entries (not inclusive)
2450            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2451            * @param retrieveFromCache whether to retrieve from the finder cache
2452            * @return the ordered range of matching document library file entries
2453            */
2454            public static List<DLFileEntry> findByG_U_F(long groupId, long userId,
2455                    long folderId, int start, int end,
2456                    OrderByComparator<DLFileEntry> orderByComparator,
2457                    boolean retrieveFromCache) {
2458                    return getPersistence()
2459                                       .findByG_U_F(groupId, userId, folderId, start, end,
2460                            orderByComparator, retrieveFromCache);
2461            }
2462    
2463            /**
2464            * Returns the first document library file entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63;.
2465            *
2466            * @param groupId the group ID
2467            * @param userId the user ID
2468            * @param folderId the folder ID
2469            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2470            * @return the first matching document library file entry
2471            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
2472            */
2473            public static DLFileEntry findByG_U_F_First(long groupId, long userId,
2474                    long folderId, OrderByComparator<DLFileEntry> orderByComparator)
2475                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2476                    return getPersistence()
2477                                       .findByG_U_F_First(groupId, userId, folderId,
2478                            orderByComparator);
2479            }
2480    
2481            /**
2482            * Returns the first document library file entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63;.
2483            *
2484            * @param groupId the group ID
2485            * @param userId the user ID
2486            * @param folderId the folder ID
2487            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2488            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2489            */
2490            public static DLFileEntry fetchByG_U_F_First(long groupId, long userId,
2491                    long folderId, OrderByComparator<DLFileEntry> orderByComparator) {
2492                    return getPersistence()
2493                                       .fetchByG_U_F_First(groupId, userId, folderId,
2494                            orderByComparator);
2495            }
2496    
2497            /**
2498            * Returns the last document library file entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63;.
2499            *
2500            * @param groupId the group ID
2501            * @param userId the user ID
2502            * @param folderId the folder ID
2503            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2504            * @return the last matching document library file entry
2505            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
2506            */
2507            public static DLFileEntry findByG_U_F_Last(long groupId, long userId,
2508                    long folderId, OrderByComparator<DLFileEntry> orderByComparator)
2509                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2510                    return getPersistence()
2511                                       .findByG_U_F_Last(groupId, userId, folderId,
2512                            orderByComparator);
2513            }
2514    
2515            /**
2516            * Returns the last document library file entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63;.
2517            *
2518            * @param groupId the group ID
2519            * @param userId the user ID
2520            * @param folderId the folder ID
2521            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2522            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2523            */
2524            public static DLFileEntry fetchByG_U_F_Last(long groupId, long userId,
2525                    long folderId, OrderByComparator<DLFileEntry> orderByComparator) {
2526                    return getPersistence()
2527                                       .fetchByG_U_F_Last(groupId, userId, folderId,
2528                            orderByComparator);
2529            }
2530    
2531            /**
2532            * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63;.
2533            *
2534            * @param fileEntryId the primary key of the current document library file entry
2535            * @param groupId the group ID
2536            * @param userId the user ID
2537            * @param folderId the folder ID
2538            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2539            * @return the previous, current, and next document library file entry
2540            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
2541            */
2542            public static DLFileEntry[] findByG_U_F_PrevAndNext(long fileEntryId,
2543                    long groupId, long userId, long folderId,
2544                    OrderByComparator<DLFileEntry> orderByComparator)
2545                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2546                    return getPersistence()
2547                                       .findByG_U_F_PrevAndNext(fileEntryId, groupId, userId,
2548                            folderId, orderByComparator);
2549            }
2550    
2551            /**
2552            * Returns all the document library file entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63;.
2553            *
2554            * @param groupId the group ID
2555            * @param userId the user ID
2556            * @param folderId the folder ID
2557            * @return the matching document library file entries that the user has permission to view
2558            */
2559            public static List<DLFileEntry> filterFindByG_U_F(long groupId,
2560                    long userId, long folderId) {
2561                    return getPersistence().filterFindByG_U_F(groupId, userId, folderId);
2562            }
2563    
2564            /**
2565            * Returns a range of all the document library file entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63;.
2566            *
2567            * <p>
2568            * 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 DLFileEntryModelImpl}. 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.
2569            * </p>
2570            *
2571            * @param groupId the group ID
2572            * @param userId the user ID
2573            * @param folderId the folder ID
2574            * @param start the lower bound of the range of document library file entries
2575            * @param end the upper bound of the range of document library file entries (not inclusive)
2576            * @return the range of matching document library file entries that the user has permission to view
2577            */
2578            public static List<DLFileEntry> filterFindByG_U_F(long groupId,
2579                    long userId, long folderId, int start, int end) {
2580                    return getPersistence()
2581                                       .filterFindByG_U_F(groupId, userId, folderId, start, end);
2582            }
2583    
2584            /**
2585            * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = &#63; and userId = &#63; and folderId = &#63;.
2586            *
2587            * <p>
2588            * 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 DLFileEntryModelImpl}. 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.
2589            * </p>
2590            *
2591            * @param groupId the group ID
2592            * @param userId the user ID
2593            * @param folderId the folder ID
2594            * @param start the lower bound of the range of document library file entries
2595            * @param end the upper bound of the range of document library file entries (not inclusive)
2596            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2597            * @return the ordered range of matching document library file entries that the user has permission to view
2598            */
2599            public static List<DLFileEntry> filterFindByG_U_F(long groupId,
2600                    long userId, long folderId, int start, int end,
2601                    OrderByComparator<DLFileEntry> orderByComparator) {
2602                    return getPersistence()
2603                                       .filterFindByG_U_F(groupId, userId, folderId, start, end,
2604                            orderByComparator);
2605            }
2606    
2607            /**
2608            * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63;.
2609            *
2610            * @param fileEntryId the primary key of the current document library file entry
2611            * @param groupId the group ID
2612            * @param userId the user ID
2613            * @param folderId the folder ID
2614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2615            * @return the previous, current, and next document library file entry
2616            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
2617            */
2618            public static DLFileEntry[] filterFindByG_U_F_PrevAndNext(
2619                    long fileEntryId, long groupId, long userId, long folderId,
2620                    OrderByComparator<DLFileEntry> orderByComparator)
2621                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2622                    return getPersistence()
2623                                       .filterFindByG_U_F_PrevAndNext(fileEntryId, groupId, userId,
2624                            folderId, orderByComparator);
2625            }
2626    
2627            /**
2628            * Returns all the document library file entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63;.
2629            *
2630            * @param groupId the group ID
2631            * @param userId the user ID
2632            * @param folderIds the folder IDs
2633            * @return the matching document library file entries that the user has permission to view
2634            */
2635            public static List<DLFileEntry> filterFindByG_U_F(long groupId,
2636                    long userId, long[] folderIds) {
2637                    return getPersistence().filterFindByG_U_F(groupId, userId, folderIds);
2638            }
2639    
2640            /**
2641            * Returns a range of all the document library file entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63;.
2642            *
2643            * <p>
2644            * 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 DLFileEntryModelImpl}. 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.
2645            * </p>
2646            *
2647            * @param groupId the group ID
2648            * @param userId the user ID
2649            * @param folderIds the folder IDs
2650            * @param start the lower bound of the range of document library file entries
2651            * @param end the upper bound of the range of document library file entries (not inclusive)
2652            * @return the range of matching document library file entries that the user has permission to view
2653            */
2654            public static List<DLFileEntry> filterFindByG_U_F(long groupId,
2655                    long userId, long[] folderIds, int start, int end) {
2656                    return getPersistence()
2657                                       .filterFindByG_U_F(groupId, userId, folderIds, start, end);
2658            }
2659    
2660            /**
2661            * Returns an ordered range of all the document library file entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63;.
2662            *
2663            * <p>
2664            * 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 DLFileEntryModelImpl}. 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.
2665            * </p>
2666            *
2667            * @param groupId the group ID
2668            * @param userId the user ID
2669            * @param folderIds the folder IDs
2670            * @param start the lower bound of the range of document library file entries
2671            * @param end the upper bound of the range of document library file entries (not inclusive)
2672            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2673            * @return the ordered range of matching document library file entries that the user has permission to view
2674            */
2675            public static List<DLFileEntry> filterFindByG_U_F(long groupId,
2676                    long userId, long[] folderIds, int start, int end,
2677                    OrderByComparator<DLFileEntry> orderByComparator) {
2678                    return getPersistence()
2679                                       .filterFindByG_U_F(groupId, userId, folderIds, start, end,
2680                            orderByComparator);
2681            }
2682    
2683            /**
2684            * Returns all the document library file entries where groupId = &#63; and userId = &#63; and folderId = any &#63;.
2685            *
2686            * <p>
2687            * 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 DLFileEntryModelImpl}. 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.
2688            * </p>
2689            *
2690            * @param groupId the group ID
2691            * @param userId the user ID
2692            * @param folderIds the folder IDs
2693            * @return the matching document library file entries
2694            */
2695            public static List<DLFileEntry> findByG_U_F(long groupId, long userId,
2696                    long[] folderIds) {
2697                    return getPersistence().findByG_U_F(groupId, userId, folderIds);
2698            }
2699    
2700            /**
2701            * Returns a range of all the document library file entries where groupId = &#63; and userId = &#63; and folderId = any &#63;.
2702            *
2703            * <p>
2704            * 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 DLFileEntryModelImpl}. 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.
2705            * </p>
2706            *
2707            * @param groupId the group ID
2708            * @param userId the user ID
2709            * @param folderIds the folder IDs
2710            * @param start the lower bound of the range of document library file entries
2711            * @param end the upper bound of the range of document library file entries (not inclusive)
2712            * @return the range of matching document library file entries
2713            */
2714            public static List<DLFileEntry> findByG_U_F(long groupId, long userId,
2715                    long[] folderIds, int start, int end) {
2716                    return getPersistence()
2717                                       .findByG_U_F(groupId, userId, folderIds, start, end);
2718            }
2719    
2720            /**
2721            * Returns an ordered range of all the document library file entries where groupId = &#63; and userId = &#63; and folderId = any &#63;.
2722            *
2723            * <p>
2724            * 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 DLFileEntryModelImpl}. 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.
2725            * </p>
2726            *
2727            * @param groupId the group ID
2728            * @param userId the user ID
2729            * @param folderIds the folder IDs
2730            * @param start the lower bound of the range of document library file entries
2731            * @param end the upper bound of the range of document library file entries (not inclusive)
2732            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2733            * @return the ordered range of matching document library file entries
2734            */
2735            public static List<DLFileEntry> findByG_U_F(long groupId, long userId,
2736                    long[] folderIds, int start, int end,
2737                    OrderByComparator<DLFileEntry> orderByComparator) {
2738                    return getPersistence()
2739                                       .findByG_U_F(groupId, userId, folderIds, start, end,
2740                            orderByComparator);
2741            }
2742    
2743            /**
2744            * Returns an ordered range of all the document library file entries where groupId = &#63; and userId = &#63; and folderId = &#63;, optionally using the finder cache.
2745            *
2746            * <p>
2747            * 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 DLFileEntryModelImpl}. 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.
2748            * </p>
2749            *
2750            * @param groupId the group ID
2751            * @param userId the user ID
2752            * @param folderId the folder ID
2753            * @param start the lower bound of the range of document library file entries
2754            * @param end the upper bound of the range of document library file entries (not inclusive)
2755            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2756            * @param retrieveFromCache whether to retrieve from the finder cache
2757            * @return the ordered range of matching document library file entries
2758            */
2759            public static List<DLFileEntry> findByG_U_F(long groupId, long userId,
2760                    long[] folderIds, int start, int end,
2761                    OrderByComparator<DLFileEntry> orderByComparator,
2762                    boolean retrieveFromCache) {
2763                    return getPersistence()
2764                                       .findByG_U_F(groupId, userId, folderIds, start, end,
2765                            orderByComparator, retrieveFromCache);
2766            }
2767    
2768            /**
2769            * Removes all the document library file entries where groupId = &#63; and userId = &#63; and folderId = &#63; from the database.
2770            *
2771            * @param groupId the group ID
2772            * @param userId the user ID
2773            * @param folderId the folder ID
2774            */
2775            public static void removeByG_U_F(long groupId, long userId, long folderId) {
2776                    getPersistence().removeByG_U_F(groupId, userId, folderId);
2777            }
2778    
2779            /**
2780            * Returns the number of document library file entries where groupId = &#63; and userId = &#63; and folderId = &#63;.
2781            *
2782            * @param groupId the group ID
2783            * @param userId the user ID
2784            * @param folderId the folder ID
2785            * @return the number of matching document library file entries
2786            */
2787            public static int countByG_U_F(long groupId, long userId, long folderId) {
2788                    return getPersistence().countByG_U_F(groupId, userId, folderId);
2789            }
2790    
2791            /**
2792            * Returns the number of document library file entries where groupId = &#63; and userId = &#63; and folderId = any &#63;.
2793            *
2794            * @param groupId the group ID
2795            * @param userId the user ID
2796            * @param folderIds the folder IDs
2797            * @return the number of matching document library file entries
2798            */
2799            public static int countByG_U_F(long groupId, long userId, long[] folderIds) {
2800                    return getPersistence().countByG_U_F(groupId, userId, folderIds);
2801            }
2802    
2803            /**
2804            * Returns the number of document library file entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63;.
2805            *
2806            * @param groupId the group ID
2807            * @param userId the user ID
2808            * @param folderId the folder ID
2809            * @return the number of matching document library file entries that the user has permission to view
2810            */
2811            public static int filterCountByG_U_F(long groupId, long userId,
2812                    long folderId) {
2813                    return getPersistence().filterCountByG_U_F(groupId, userId, folderId);
2814            }
2815    
2816            /**
2817            * Returns the number of document library file entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63;.
2818            *
2819            * @param groupId the group ID
2820            * @param userId the user ID
2821            * @param folderIds the folder IDs
2822            * @return the number of matching document library file entries that the user has permission to view
2823            */
2824            public static int filterCountByG_U_F(long groupId, long userId,
2825                    long[] folderIds) {
2826                    return getPersistence().filterCountByG_U_F(groupId, userId, folderIds);
2827            }
2828    
2829            /**
2830            * Returns the document library file entry where groupId = &#63; and folderId = &#63; and name = &#63; or throws a {@link NoSuchFileEntryException} if it could not be found.
2831            *
2832            * @param groupId the group ID
2833            * @param folderId the folder ID
2834            * @param name the name
2835            * @return the matching document library file entry
2836            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
2837            */
2838            public static DLFileEntry findByG_F_N(long groupId, long folderId,
2839                    java.lang.String name)
2840                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2841                    return getPersistence().findByG_F_N(groupId, folderId, name);
2842            }
2843    
2844            /**
2845            * Returns the document library file entry where groupId = &#63; and folderId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
2846            *
2847            * @param groupId the group ID
2848            * @param folderId the folder ID
2849            * @param name the name
2850            * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2851            */
2852            public static DLFileEntry fetchByG_F_N(long groupId, long folderId,
2853                    java.lang.String name) {
2854                    return getPersistence().fetchByG_F_N(groupId, folderId, name);
2855            }
2856    
2857            /**
2858            * Returns the document library file entry where groupId = &#63; and folderId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
2859            *
2860            * @param groupId the group ID
2861            * @param folderId the folder ID
2862            * @param name the name
2863            * @param retrieveFromCache whether to retrieve from the finder cache
2864            * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2865            */
2866            public static DLFileEntry fetchByG_F_N(long groupId, long folderId,
2867                    java.lang.String name, boolean retrieveFromCache) {
2868                    return getPersistence()
2869                                       .fetchByG_F_N(groupId, folderId, name, retrieveFromCache);
2870            }
2871    
2872            /**
2873            * Removes the document library file entry where groupId = &#63; and folderId = &#63; and name = &#63; from the database.
2874            *
2875            * @param groupId the group ID
2876            * @param folderId the folder ID
2877            * @param name the name
2878            * @return the document library file entry that was removed
2879            */
2880            public static DLFileEntry removeByG_F_N(long groupId, long folderId,
2881                    java.lang.String name)
2882                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2883                    return getPersistence().removeByG_F_N(groupId, folderId, name);
2884            }
2885    
2886            /**
2887            * Returns the number of document library file entries where groupId = &#63; and folderId = &#63; and name = &#63;.
2888            *
2889            * @param groupId the group ID
2890            * @param folderId the folder ID
2891            * @param name the name
2892            * @return the number of matching document library file entries
2893            */
2894            public static int countByG_F_N(long groupId, long folderId,
2895                    java.lang.String name) {
2896                    return getPersistence().countByG_F_N(groupId, folderId, name);
2897            }
2898    
2899            /**
2900            * Returns the document library file entry where groupId = &#63; and folderId = &#63; and fileName = &#63; or throws a {@link NoSuchFileEntryException} if it could not be found.
2901            *
2902            * @param groupId the group ID
2903            * @param folderId the folder ID
2904            * @param fileName the file name
2905            * @return the matching document library file entry
2906            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
2907            */
2908            public static DLFileEntry findByG_F_FN(long groupId, long folderId,
2909                    java.lang.String fileName)
2910                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2911                    return getPersistence().findByG_F_FN(groupId, folderId, fileName);
2912            }
2913    
2914            /**
2915            * Returns the document library file entry where groupId = &#63; and folderId = &#63; and fileName = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
2916            *
2917            * @param groupId the group ID
2918            * @param folderId the folder ID
2919            * @param fileName the file name
2920            * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2921            */
2922            public static DLFileEntry fetchByG_F_FN(long groupId, long folderId,
2923                    java.lang.String fileName) {
2924                    return getPersistence().fetchByG_F_FN(groupId, folderId, fileName);
2925            }
2926    
2927            /**
2928            * Returns the document library file entry where groupId = &#63; and folderId = &#63; and fileName = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
2929            *
2930            * @param groupId the group ID
2931            * @param folderId the folder ID
2932            * @param fileName the file name
2933            * @param retrieveFromCache whether to retrieve from the finder cache
2934            * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2935            */
2936            public static DLFileEntry fetchByG_F_FN(long groupId, long folderId,
2937                    java.lang.String fileName, boolean retrieveFromCache) {
2938                    return getPersistence()
2939                                       .fetchByG_F_FN(groupId, folderId, fileName, retrieveFromCache);
2940            }
2941    
2942            /**
2943            * Removes the document library file entry where groupId = &#63; and folderId = &#63; and fileName = &#63; from the database.
2944            *
2945            * @param groupId the group ID
2946            * @param folderId the folder ID
2947            * @param fileName the file name
2948            * @return the document library file entry that was removed
2949            */
2950            public static DLFileEntry removeByG_F_FN(long groupId, long folderId,
2951                    java.lang.String fileName)
2952                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2953                    return getPersistence().removeByG_F_FN(groupId, folderId, fileName);
2954            }
2955    
2956            /**
2957            * Returns the number of document library file entries where groupId = &#63; and folderId = &#63; and fileName = &#63;.
2958            *
2959            * @param groupId the group ID
2960            * @param folderId the folder ID
2961            * @param fileName the file name
2962            * @return the number of matching document library file entries
2963            */
2964            public static int countByG_F_FN(long groupId, long folderId,
2965                    java.lang.String fileName) {
2966                    return getPersistence().countByG_F_FN(groupId, folderId, fileName);
2967            }
2968    
2969            /**
2970            * Returns the document library file entry where groupId = &#63; and folderId = &#63; and title = &#63; or throws a {@link NoSuchFileEntryException} if it could not be found.
2971            *
2972            * @param groupId the group ID
2973            * @param folderId the folder ID
2974            * @param title the title
2975            * @return the matching document library file entry
2976            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
2977            */
2978            public static DLFileEntry findByG_F_T(long groupId, long folderId,
2979                    java.lang.String title)
2980                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
2981                    return getPersistence().findByG_F_T(groupId, folderId, title);
2982            }
2983    
2984            /**
2985            * Returns the document library file entry where groupId = &#63; and folderId = &#63; and title = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
2986            *
2987            * @param groupId the group ID
2988            * @param folderId the folder ID
2989            * @param title the title
2990            * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
2991            */
2992            public static DLFileEntry fetchByG_F_T(long groupId, long folderId,
2993                    java.lang.String title) {
2994                    return getPersistence().fetchByG_F_T(groupId, folderId, title);
2995            }
2996    
2997            /**
2998            * Returns the document library file entry where groupId = &#63; and folderId = &#63; and title = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
2999            *
3000            * @param groupId the group ID
3001            * @param folderId the folder ID
3002            * @param title the title
3003            * @param retrieveFromCache whether to retrieve from the finder cache
3004            * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
3005            */
3006            public static DLFileEntry fetchByG_F_T(long groupId, long folderId,
3007                    java.lang.String title, boolean retrieveFromCache) {
3008                    return getPersistence()
3009                                       .fetchByG_F_T(groupId, folderId, title, retrieveFromCache);
3010            }
3011    
3012            /**
3013            * Removes the document library file entry where groupId = &#63; and folderId = &#63; and title = &#63; from the database.
3014            *
3015            * @param groupId the group ID
3016            * @param folderId the folder ID
3017            * @param title the title
3018            * @return the document library file entry that was removed
3019            */
3020            public static DLFileEntry removeByG_F_T(long groupId, long folderId,
3021                    java.lang.String title)
3022                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
3023                    return getPersistence().removeByG_F_T(groupId, folderId, title);
3024            }
3025    
3026            /**
3027            * Returns the number of document library file entries where groupId = &#63; and folderId = &#63; and title = &#63;.
3028            *
3029            * @param groupId the group ID
3030            * @param folderId the folder ID
3031            * @param title the title
3032            * @return the number of matching document library file entries
3033            */
3034            public static int countByG_F_T(long groupId, long folderId,
3035                    java.lang.String title) {
3036                    return getPersistence().countByG_F_T(groupId, folderId, title);
3037            }
3038    
3039            /**
3040            * Returns all the document library file entries where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3041            *
3042            * @param groupId the group ID
3043            * @param folderId the folder ID
3044            * @param fileEntryTypeId the file entry type ID
3045            * @return the matching document library file entries
3046            */
3047            public static List<DLFileEntry> findByG_F_F(long groupId, long folderId,
3048                    long fileEntryTypeId) {
3049                    return getPersistence().findByG_F_F(groupId, folderId, fileEntryTypeId);
3050            }
3051    
3052            /**
3053            * Returns a range of all the document library file entries where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3054            *
3055            * <p>
3056            * 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 DLFileEntryModelImpl}. 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.
3057            * </p>
3058            *
3059            * @param groupId the group ID
3060            * @param folderId the folder ID
3061            * @param fileEntryTypeId the file entry type ID
3062            * @param start the lower bound of the range of document library file entries
3063            * @param end the upper bound of the range of document library file entries (not inclusive)
3064            * @return the range of matching document library file entries
3065            */
3066            public static List<DLFileEntry> findByG_F_F(long groupId, long folderId,
3067                    long fileEntryTypeId, int start, int end) {
3068                    return getPersistence()
3069                                       .findByG_F_F(groupId, folderId, fileEntryTypeId, start, end);
3070            }
3071    
3072            /**
3073            * Returns an ordered range of all the document library file entries where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3074            *
3075            * <p>
3076            * 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 DLFileEntryModelImpl}. 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.
3077            * </p>
3078            *
3079            * @param groupId the group ID
3080            * @param folderId the folder ID
3081            * @param fileEntryTypeId the file entry type ID
3082            * @param start the lower bound of the range of document library file entries
3083            * @param end the upper bound of the range of document library file entries (not inclusive)
3084            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3085            * @return the ordered range of matching document library file entries
3086            */
3087            public static List<DLFileEntry> findByG_F_F(long groupId, long folderId,
3088                    long fileEntryTypeId, int start, int end,
3089                    OrderByComparator<DLFileEntry> orderByComparator) {
3090                    return getPersistence()
3091                                       .findByG_F_F(groupId, folderId, fileEntryTypeId, start, end,
3092                            orderByComparator);
3093            }
3094    
3095            /**
3096            * Returns an ordered range of all the document library file entries where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3097            *
3098            * <p>
3099            * 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 DLFileEntryModelImpl}. 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.
3100            * </p>
3101            *
3102            * @param groupId the group ID
3103            * @param folderId the folder ID
3104            * @param fileEntryTypeId the file entry type ID
3105            * @param start the lower bound of the range of document library file entries
3106            * @param end the upper bound of the range of document library file entries (not inclusive)
3107            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3108            * @param retrieveFromCache whether to retrieve from the finder cache
3109            * @return the ordered range of matching document library file entries
3110            */
3111            public static List<DLFileEntry> findByG_F_F(long groupId, long folderId,
3112                    long fileEntryTypeId, int start, int end,
3113                    OrderByComparator<DLFileEntry> orderByComparator,
3114                    boolean retrieveFromCache) {
3115                    return getPersistence()
3116                                       .findByG_F_F(groupId, folderId, fileEntryTypeId, start, end,
3117                            orderByComparator, retrieveFromCache);
3118            }
3119    
3120            /**
3121            * Returns the first document library file entry in the ordered set where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3122            *
3123            * @param groupId the group ID
3124            * @param folderId the folder ID
3125            * @param fileEntryTypeId the file entry type ID
3126            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3127            * @return the first matching document library file entry
3128            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
3129            */
3130            public static DLFileEntry findByG_F_F_First(long groupId, long folderId,
3131                    long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator)
3132                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
3133                    return getPersistence()
3134                                       .findByG_F_F_First(groupId, folderId, fileEntryTypeId,
3135                            orderByComparator);
3136            }
3137    
3138            /**
3139            * Returns the first document library file entry in the ordered set where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3140            *
3141            * @param groupId the group ID
3142            * @param folderId the folder ID
3143            * @param fileEntryTypeId the file entry type ID
3144            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3145            * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
3146            */
3147            public static DLFileEntry fetchByG_F_F_First(long groupId, long folderId,
3148                    long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) {
3149                    return getPersistence()
3150                                       .fetchByG_F_F_First(groupId, folderId, fileEntryTypeId,
3151                            orderByComparator);
3152            }
3153    
3154            /**
3155            * Returns the last document library file entry in the ordered set where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3156            *
3157            * @param groupId the group ID
3158            * @param folderId the folder ID
3159            * @param fileEntryTypeId the file entry type ID
3160            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3161            * @return the last matching document library file entry
3162            * @throws NoSuchFileEntryException if a matching document library file entry could not be found
3163            */
3164            public static DLFileEntry findByG_F_F_Last(long groupId, long folderId,
3165                    long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator)
3166                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
3167                    return getPersistence()
3168                                       .findByG_F_F_Last(groupId, folderId, fileEntryTypeId,
3169                            orderByComparator);
3170            }
3171    
3172            /**
3173            * Returns the last document library file entry in the ordered set where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3174            *
3175            * @param groupId the group ID
3176            * @param folderId the folder ID
3177            * @param fileEntryTypeId the file entry type ID
3178            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3179            * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found
3180            */
3181            public static DLFileEntry fetchByG_F_F_Last(long groupId, long folderId,
3182                    long fileEntryTypeId, OrderByComparator<DLFileEntry> orderByComparator) {
3183                    return getPersistence()
3184                                       .fetchByG_F_F_Last(groupId, folderId, fileEntryTypeId,
3185                            orderByComparator);
3186            }
3187    
3188            /**
3189            * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3190            *
3191            * @param fileEntryId the primary key of the current document library file entry
3192            * @param groupId the group ID
3193            * @param folderId the folder ID
3194            * @param fileEntryTypeId the file entry type ID
3195            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3196            * @return the previous, current, and next document library file entry
3197            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
3198            */
3199            public static DLFileEntry[] findByG_F_F_PrevAndNext(long fileEntryId,
3200                    long groupId, long folderId, long fileEntryTypeId,
3201                    OrderByComparator<DLFileEntry> orderByComparator)
3202                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
3203                    return getPersistence()
3204                                       .findByG_F_F_PrevAndNext(fileEntryId, groupId, folderId,
3205                            fileEntryTypeId, orderByComparator);
3206            }
3207    
3208            /**
3209            * Returns all the document library file entries that the user has permission to view where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3210            *
3211            * @param groupId the group ID
3212            * @param folderId the folder ID
3213            * @param fileEntryTypeId the file entry type ID
3214            * @return the matching document library file entries that the user has permission to view
3215            */
3216            public static List<DLFileEntry> filterFindByG_F_F(long groupId,
3217                    long folderId, long fileEntryTypeId) {
3218                    return getPersistence()
3219                                       .filterFindByG_F_F(groupId, folderId, fileEntryTypeId);
3220            }
3221    
3222            /**
3223            * Returns a range of all the document library file entries that the user has permission to view where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3224            *
3225            * <p>
3226            * 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 DLFileEntryModelImpl}. 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.
3227            * </p>
3228            *
3229            * @param groupId the group ID
3230            * @param folderId the folder ID
3231            * @param fileEntryTypeId the file entry type ID
3232            * @param start the lower bound of the range of document library file entries
3233            * @param end the upper bound of the range of document library file entries (not inclusive)
3234            * @return the range of matching document library file entries that the user has permission to view
3235            */
3236            public static List<DLFileEntry> filterFindByG_F_F(long groupId,
3237                    long folderId, long fileEntryTypeId, int start, int end) {
3238                    return getPersistence()
3239                                       .filterFindByG_F_F(groupId, folderId, fileEntryTypeId,
3240                            start, end);
3241            }
3242    
3243            /**
3244            * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3245            *
3246            * <p>
3247            * 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 DLFileEntryModelImpl}. 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.
3248            * </p>
3249            *
3250            * @param groupId the group ID
3251            * @param folderId the folder ID
3252            * @param fileEntryTypeId the file entry type ID
3253            * @param start the lower bound of the range of document library file entries
3254            * @param end the upper bound of the range of document library file entries (not inclusive)
3255            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3256            * @return the ordered range of matching document library file entries that the user has permission to view
3257            */
3258            public static List<DLFileEntry> filterFindByG_F_F(long groupId,
3259                    long folderId, long fileEntryTypeId, int start, int end,
3260                    OrderByComparator<DLFileEntry> orderByComparator) {
3261                    return getPersistence()
3262                                       .filterFindByG_F_F(groupId, folderId, fileEntryTypeId,
3263                            start, end, orderByComparator);
3264            }
3265    
3266            /**
3267            * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3268            *
3269            * @param fileEntryId the primary key of the current document library file entry
3270            * @param groupId the group ID
3271            * @param folderId the folder ID
3272            * @param fileEntryTypeId the file entry type ID
3273            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3274            * @return the previous, current, and next document library file entry
3275            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
3276            */
3277            public static DLFileEntry[] filterFindByG_F_F_PrevAndNext(
3278                    long fileEntryId, long groupId, long folderId, long fileEntryTypeId,
3279                    OrderByComparator<DLFileEntry> orderByComparator)
3280                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
3281                    return getPersistence()
3282                                       .filterFindByG_F_F_PrevAndNext(fileEntryId, groupId,
3283                            folderId, fileEntryTypeId, orderByComparator);
3284            }
3285    
3286            /**
3287            * Returns all the document library file entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and fileEntryTypeId = &#63;.
3288            *
3289            * @param groupId the group ID
3290            * @param folderIds the folder IDs
3291            * @param fileEntryTypeId the file entry type ID
3292            * @return the matching document library file entries that the user has permission to view
3293            */
3294            public static List<DLFileEntry> filterFindByG_F_F(long groupId,
3295                    long[] folderIds, long fileEntryTypeId) {
3296                    return getPersistence()
3297                                       .filterFindByG_F_F(groupId, folderIds, fileEntryTypeId);
3298            }
3299    
3300            /**
3301            * Returns a range of all the document library file entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and fileEntryTypeId = &#63;.
3302            *
3303            * <p>
3304            * 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 DLFileEntryModelImpl}. 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.
3305            * </p>
3306            *
3307            * @param groupId the group ID
3308            * @param folderIds the folder IDs
3309            * @param fileEntryTypeId the file entry type ID
3310            * @param start the lower bound of the range of document library file entries
3311            * @param end the upper bound of the range of document library file entries (not inclusive)
3312            * @return the range of matching document library file entries that the user has permission to view
3313            */
3314            public static List<DLFileEntry> filterFindByG_F_F(long groupId,
3315                    long[] folderIds, long fileEntryTypeId, int start, int end) {
3316                    return getPersistence()
3317                                       .filterFindByG_F_F(groupId, folderIds, fileEntryTypeId,
3318                            start, end);
3319            }
3320    
3321            /**
3322            * Returns an ordered range of all the document library file entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and fileEntryTypeId = &#63;.
3323            *
3324            * <p>
3325            * 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 DLFileEntryModelImpl}. 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.
3326            * </p>
3327            *
3328            * @param groupId the group ID
3329            * @param folderIds the folder IDs
3330            * @param fileEntryTypeId the file entry type ID
3331            * @param start the lower bound of the range of document library file entries
3332            * @param end the upper bound of the range of document library file entries (not inclusive)
3333            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3334            * @return the ordered range of matching document library file entries that the user has permission to view
3335            */
3336            public static List<DLFileEntry> filterFindByG_F_F(long groupId,
3337                    long[] folderIds, long fileEntryTypeId, int start, int end,
3338                    OrderByComparator<DLFileEntry> orderByComparator) {
3339                    return getPersistence()
3340                                       .filterFindByG_F_F(groupId, folderIds, fileEntryTypeId,
3341                            start, end, orderByComparator);
3342            }
3343    
3344            /**
3345            * Returns all the document library file entries where groupId = &#63; and folderId = any &#63; and fileEntryTypeId = &#63;.
3346            *
3347            * <p>
3348            * 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 DLFileEntryModelImpl}. 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.
3349            * </p>
3350            *
3351            * @param groupId the group ID
3352            * @param folderIds the folder IDs
3353            * @param fileEntryTypeId the file entry type ID
3354            * @return the matching document library file entries
3355            */
3356            public static List<DLFileEntry> findByG_F_F(long groupId, long[] folderIds,
3357                    long fileEntryTypeId) {
3358                    return getPersistence().findByG_F_F(groupId, folderIds, fileEntryTypeId);
3359            }
3360    
3361            /**
3362            * Returns a range of all the document library file entries where groupId = &#63; and folderId = any &#63; and fileEntryTypeId = &#63;.
3363            *
3364            * <p>
3365            * 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 DLFileEntryModelImpl}. 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.
3366            * </p>
3367            *
3368            * @param groupId the group ID
3369            * @param folderIds the folder IDs
3370            * @param fileEntryTypeId the file entry type ID
3371            * @param start the lower bound of the range of document library file entries
3372            * @param end the upper bound of the range of document library file entries (not inclusive)
3373            * @return the range of matching document library file entries
3374            */
3375            public static List<DLFileEntry> findByG_F_F(long groupId, long[] folderIds,
3376                    long fileEntryTypeId, int start, int end) {
3377                    return getPersistence()
3378                                       .findByG_F_F(groupId, folderIds, fileEntryTypeId, start, end);
3379            }
3380    
3381            /**
3382            * Returns an ordered range of all the document library file entries where groupId = &#63; and folderId = any &#63; and fileEntryTypeId = &#63;.
3383            *
3384            * <p>
3385            * 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 DLFileEntryModelImpl}. 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.
3386            * </p>
3387            *
3388            * @param groupId the group ID
3389            * @param folderIds the folder IDs
3390            * @param fileEntryTypeId the file entry type ID
3391            * @param start the lower bound of the range of document library file entries
3392            * @param end the upper bound of the range of document library file entries (not inclusive)
3393            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3394            * @return the ordered range of matching document library file entries
3395            */
3396            public static List<DLFileEntry> findByG_F_F(long groupId, long[] folderIds,
3397                    long fileEntryTypeId, int start, int end,
3398                    OrderByComparator<DLFileEntry> orderByComparator) {
3399                    return getPersistence()
3400                                       .findByG_F_F(groupId, folderIds, fileEntryTypeId, start,
3401                            end, orderByComparator);
3402            }
3403    
3404            /**
3405            * Returns an ordered range of all the document library file entries where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;, optionally using the finder cache.
3406            *
3407            * <p>
3408            * 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 DLFileEntryModelImpl}. 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.
3409            * </p>
3410            *
3411            * @param groupId the group ID
3412            * @param folderId the folder ID
3413            * @param fileEntryTypeId the file entry type ID
3414            * @param start the lower bound of the range of document library file entries
3415            * @param end the upper bound of the range of document library file entries (not inclusive)
3416            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3417            * @param retrieveFromCache whether to retrieve from the finder cache
3418            * @return the ordered range of matching document library file entries
3419            */
3420            public static List<DLFileEntry> findByG_F_F(long groupId, long[] folderIds,
3421                    long fileEntryTypeId, int start, int end,
3422                    OrderByComparator<DLFileEntry> orderByComparator,
3423                    boolean retrieveFromCache) {
3424                    return getPersistence()
3425                                       .findByG_F_F(groupId, folderIds, fileEntryTypeId, start,
3426                            end, orderByComparator, retrieveFromCache);
3427            }
3428    
3429            /**
3430            * Removes all the document library file entries where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63; from the database.
3431            *
3432            * @param groupId the group ID
3433            * @param folderId the folder ID
3434            * @param fileEntryTypeId the file entry type ID
3435            */
3436            public static void removeByG_F_F(long groupId, long folderId,
3437                    long fileEntryTypeId) {
3438                    getPersistence().removeByG_F_F(groupId, folderId, fileEntryTypeId);
3439            }
3440    
3441            /**
3442            * Returns the number of document library file entries where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3443            *
3444            * @param groupId the group ID
3445            * @param folderId the folder ID
3446            * @param fileEntryTypeId the file entry type ID
3447            * @return the number of matching document library file entries
3448            */
3449            public static int countByG_F_F(long groupId, long folderId,
3450                    long fileEntryTypeId) {
3451                    return getPersistence().countByG_F_F(groupId, folderId, fileEntryTypeId);
3452            }
3453    
3454            /**
3455            * Returns the number of document library file entries where groupId = &#63; and folderId = any &#63; and fileEntryTypeId = &#63;.
3456            *
3457            * @param groupId the group ID
3458            * @param folderIds the folder IDs
3459            * @param fileEntryTypeId the file entry type ID
3460            * @return the number of matching document library file entries
3461            */
3462            public static int countByG_F_F(long groupId, long[] folderIds,
3463                    long fileEntryTypeId) {
3464                    return getPersistence().countByG_F_F(groupId, folderIds, fileEntryTypeId);
3465            }
3466    
3467            /**
3468            * Returns the number of document library file entries that the user has permission to view where groupId = &#63; and folderId = &#63; and fileEntryTypeId = &#63;.
3469            *
3470            * @param groupId the group ID
3471            * @param folderId the folder ID
3472            * @param fileEntryTypeId the file entry type ID
3473            * @return the number of matching document library file entries that the user has permission to view
3474            */
3475            public static int filterCountByG_F_F(long groupId, long folderId,
3476                    long fileEntryTypeId) {
3477                    return getPersistence()
3478                                       .filterCountByG_F_F(groupId, folderId, fileEntryTypeId);
3479            }
3480    
3481            /**
3482            * Returns the number of document library file entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and fileEntryTypeId = &#63;.
3483            *
3484            * @param groupId the group ID
3485            * @param folderIds the folder IDs
3486            * @param fileEntryTypeId the file entry type ID
3487            * @return the number of matching document library file entries that the user has permission to view
3488            */
3489            public static int filterCountByG_F_F(long groupId, long[] folderIds,
3490                    long fileEntryTypeId) {
3491                    return getPersistence()
3492                                       .filterCountByG_F_F(groupId, folderIds, fileEntryTypeId);
3493            }
3494    
3495            /**
3496            * Caches the document library file entry in the entity cache if it is enabled.
3497            *
3498            * @param dlFileEntry the document library file entry
3499            */
3500            public static void cacheResult(DLFileEntry dlFileEntry) {
3501                    getPersistence().cacheResult(dlFileEntry);
3502            }
3503    
3504            /**
3505            * Caches the document library file entries in the entity cache if it is enabled.
3506            *
3507            * @param dlFileEntries the document library file entries
3508            */
3509            public static void cacheResult(List<DLFileEntry> dlFileEntries) {
3510                    getPersistence().cacheResult(dlFileEntries);
3511            }
3512    
3513            /**
3514            * Creates a new document library file entry with the primary key. Does not add the document library file entry to the database.
3515            *
3516            * @param fileEntryId the primary key for the new document library file entry
3517            * @return the new document library file entry
3518            */
3519            public static DLFileEntry create(long fileEntryId) {
3520                    return getPersistence().create(fileEntryId);
3521            }
3522    
3523            /**
3524            * Removes the document library file entry with the primary key from the database. Also notifies the appropriate model listeners.
3525            *
3526            * @param fileEntryId the primary key of the document library file entry
3527            * @return the document library file entry that was removed
3528            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
3529            */
3530            public static DLFileEntry remove(long fileEntryId)
3531                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
3532                    return getPersistence().remove(fileEntryId);
3533            }
3534    
3535            public static DLFileEntry updateImpl(DLFileEntry dlFileEntry) {
3536                    return getPersistence().updateImpl(dlFileEntry);
3537            }
3538    
3539            /**
3540            * Returns the document library file entry with the primary key or throws a {@link NoSuchFileEntryException} if it could not be found.
3541            *
3542            * @param fileEntryId the primary key of the document library file entry
3543            * @return the document library file entry
3544            * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found
3545            */
3546            public static DLFileEntry findByPrimaryKey(long fileEntryId)
3547                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryException {
3548                    return getPersistence().findByPrimaryKey(fileEntryId);
3549            }
3550    
3551            /**
3552            * Returns the document library file entry with the primary key or returns <code>null</code> if it could not be found.
3553            *
3554            * @param fileEntryId the primary key of the document library file entry
3555            * @return the document library file entry, or <code>null</code> if a document library file entry with the primary key could not be found
3556            */
3557            public static DLFileEntry fetchByPrimaryKey(long fileEntryId) {
3558                    return getPersistence().fetchByPrimaryKey(fileEntryId);
3559            }
3560    
3561            public static java.util.Map<java.io.Serializable, DLFileEntry> fetchByPrimaryKeys(
3562                    java.util.Set<java.io.Serializable> primaryKeys) {
3563                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
3564            }
3565    
3566            /**
3567            * Returns all the document library file entries.
3568            *
3569            * @return the document library file entries
3570            */
3571            public static List<DLFileEntry> findAll() {
3572                    return getPersistence().findAll();
3573            }
3574    
3575            /**
3576            * Returns a range of all the document library file entries.
3577            *
3578            * <p>
3579            * 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 DLFileEntryModelImpl}. 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.
3580            * </p>
3581            *
3582            * @param start the lower bound of the range of document library file entries
3583            * @param end the upper bound of the range of document library file entries (not inclusive)
3584            * @return the range of document library file entries
3585            */
3586            public static List<DLFileEntry> findAll(int start, int end) {
3587                    return getPersistence().findAll(start, end);
3588            }
3589    
3590            /**
3591            * Returns an ordered range of all the document library file entries.
3592            *
3593            * <p>
3594            * 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 DLFileEntryModelImpl}. 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.
3595            * </p>
3596            *
3597            * @param start the lower bound of the range of document library file entries
3598            * @param end the upper bound of the range of document library file entries (not inclusive)
3599            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3600            * @return the ordered range of document library file entries
3601            */
3602            public static List<DLFileEntry> findAll(int start, int end,
3603                    OrderByComparator<DLFileEntry> orderByComparator) {
3604                    return getPersistence().findAll(start, end, orderByComparator);
3605            }
3606    
3607            /**
3608            * Returns an ordered range of all the document library file entries.
3609            *
3610            * <p>
3611            * 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 DLFileEntryModelImpl}. 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.
3612            * </p>
3613            *
3614            * @param start the lower bound of the range of document library file entries
3615            * @param end the upper bound of the range of document library file entries (not inclusive)
3616            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3617            * @param retrieveFromCache whether to retrieve from the finder cache
3618            * @return the ordered range of document library file entries
3619            */
3620            public static List<DLFileEntry> findAll(int start, int end,
3621                    OrderByComparator<DLFileEntry> orderByComparator,
3622                    boolean retrieveFromCache) {
3623                    return getPersistence()
3624                                       .findAll(start, end, orderByComparator, retrieveFromCache);
3625            }
3626    
3627            /**
3628            * Removes all the document library file entries from the database.
3629            */
3630            public static void removeAll() {
3631                    getPersistence().removeAll();
3632            }
3633    
3634            /**
3635            * Returns the number of document library file entries.
3636            *
3637            * @return the number of document library file entries
3638            */
3639            public static int countAll() {
3640                    return getPersistence().countAll();
3641            }
3642    
3643            public static java.util.Set<java.lang.String> getBadColumnNames() {
3644                    return getPersistence().getBadColumnNames();
3645            }
3646    
3647            public static DLFileEntryPersistence getPersistence() {
3648                    if (_persistence == null) {
3649                            _persistence = (DLFileEntryPersistence)PortalBeanLocatorUtil.locate(DLFileEntryPersistence.class.getName());
3650    
3651                            ReferenceRegistry.registerReference(DLFileEntryUtil.class,
3652                                    "_persistence");
3653                    }
3654    
3655                    return _persistence;
3656            }
3657    
3658            private static DLFileEntryPersistence _persistence;
3659    }