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