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