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.DLFileEntryType;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the document library file entry type service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryTypePersistenceImpl} 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 DLFileEntryTypePersistence
038     * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryTypePersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class DLFileEntryTypeUtil {
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(DLFileEntryType dlFileEntryType) {
060                    getPersistence().clearCache(dlFileEntryType);
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<DLFileEntryType> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<DLFileEntryType> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<DLFileEntryType> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<DLFileEntryType> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static DLFileEntryType update(DLFileEntryType dlFileEntryType) {
101                    return getPersistence().update(dlFileEntryType);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static DLFileEntryType update(DLFileEntryType dlFileEntryType,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(dlFileEntryType, serviceContext);
110            }
111    
112            /**
113            * Returns all the document library file entry types where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching document library file entry types
117            */
118            public static List<DLFileEntryType> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the document library file entry types where uuid = &#63;.
124            *
125            * <p>
126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of document library file entry types
131            * @param end the upper bound of the range of document library file entry types (not inclusive)
132            * @return the range of matching document library file entry types
133            */
134            public static List<DLFileEntryType> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the document library file entry types where uuid = &#63;.
141            *
142            * <p>
143            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of document library file entry types
148            * @param end the upper bound of the range of document library file entry types (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching document library file entry types
151            */
152            public static List<DLFileEntryType> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first document library file entry type in the ordered set where uuid = &#63;.
159            *
160            * @param uuid the uuid
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching document library file entry type
163            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
164            */
165            public static DLFileEntryType findByUuid_First(java.lang.String uuid,
166                    OrderByComparator<DLFileEntryType> orderByComparator)
167                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
168                    return getPersistence().findByUuid_First(uuid, orderByComparator);
169            }
170    
171            /**
172            * Returns the first document library file entry type in the ordered set where uuid = &#63;.
173            *
174            * @param uuid the uuid
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
177            */
178            public static DLFileEntryType fetchByUuid_First(java.lang.String uuid,
179                    OrderByComparator<DLFileEntryType> orderByComparator) {
180                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the last document library file entry type in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the last matching document library file entry type
189            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
190            */
191            public static DLFileEntryType findByUuid_Last(java.lang.String uuid,
192                    OrderByComparator<DLFileEntryType> orderByComparator)
193                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
194                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last document library file entry type in the ordered set where uuid = &#63;.
199            *
200            * @param uuid the uuid
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
203            */
204            public static DLFileEntryType fetchByUuid_Last(java.lang.String uuid,
205                    OrderByComparator<DLFileEntryType> orderByComparator) {
206                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
207            }
208    
209            /**
210            * Returns the document library file entry types before and after the current document library file entry type in the ordered set where uuid = &#63;.
211            *
212            * @param fileEntryTypeId the primary key of the current document library file entry type
213            * @param uuid the uuid
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the previous, current, and next document library file entry type
216            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
217            */
218            public static DLFileEntryType[] findByUuid_PrevAndNext(
219                    long fileEntryTypeId, java.lang.String uuid,
220                    OrderByComparator<DLFileEntryType> orderByComparator)
221                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
222                    return getPersistence()
223                                       .findByUuid_PrevAndNext(fileEntryTypeId, uuid,
224                            orderByComparator);
225            }
226    
227            /**
228            * Removes all the document library file entry types where uuid = &#63; from the database.
229            *
230            * @param uuid the uuid
231            */
232            public static void removeByUuid(java.lang.String uuid) {
233                    getPersistence().removeByUuid(uuid);
234            }
235    
236            /**
237            * Returns the number of document library file entry types where uuid = &#63;.
238            *
239            * @param uuid the uuid
240            * @return the number of matching document library file entry types
241            */
242            public static int countByUuid(java.lang.String uuid) {
243                    return getPersistence().countByUuid(uuid);
244            }
245    
246            /**
247            * Returns the document library file entry type where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchFileEntryTypeException} if it could not be found.
248            *
249            * @param uuid the uuid
250            * @param groupId the group ID
251            * @return the matching document library file entry type
252            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
253            */
254            public static DLFileEntryType findByUUID_G(java.lang.String uuid,
255                    long groupId)
256                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
257                    return getPersistence().findByUUID_G(uuid, groupId);
258            }
259    
260            /**
261            * Returns the document library file entry type where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
262            *
263            * @param uuid the uuid
264            * @param groupId the group ID
265            * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
266            */
267            public static DLFileEntryType fetchByUUID_G(java.lang.String uuid,
268                    long groupId) {
269                    return getPersistence().fetchByUUID_G(uuid, groupId);
270            }
271    
272            /**
273            * Returns the document library file entry type where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
274            *
275            * @param uuid the uuid
276            * @param groupId the group ID
277            * @param retrieveFromCache whether to use the finder cache
278            * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
279            */
280            public static DLFileEntryType fetchByUUID_G(java.lang.String uuid,
281                    long groupId, boolean retrieveFromCache) {
282                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
283            }
284    
285            /**
286            * Removes the document library file entry type where uuid = &#63; and groupId = &#63; from the database.
287            *
288            * @param uuid the uuid
289            * @param groupId the group ID
290            * @return the document library file entry type that was removed
291            */
292            public static DLFileEntryType removeByUUID_G(java.lang.String uuid,
293                    long groupId)
294                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
295                    return getPersistence().removeByUUID_G(uuid, groupId);
296            }
297    
298            /**
299            * Returns the number of document library file entry types where uuid = &#63; and groupId = &#63;.
300            *
301            * @param uuid the uuid
302            * @param groupId the group ID
303            * @return the number of matching document library file entry types
304            */
305            public static int countByUUID_G(java.lang.String uuid, long groupId) {
306                    return getPersistence().countByUUID_G(uuid, groupId);
307            }
308    
309            /**
310            * Returns all the document library file entry types where uuid = &#63; and companyId = &#63;.
311            *
312            * @param uuid the uuid
313            * @param companyId the company ID
314            * @return the matching document library file entry types
315            */
316            public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid,
317                    long companyId) {
318                    return getPersistence().findByUuid_C(uuid, companyId);
319            }
320    
321            /**
322            * Returns a range of all the document library file entry types where uuid = &#63; and companyId = &#63;.
323            *
324            * <p>
325            * 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 DLFileEntryTypeModelImpl}. 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.
326            * </p>
327            *
328            * @param uuid the uuid
329            * @param companyId the company ID
330            * @param start the lower bound of the range of document library file entry types
331            * @param end the upper bound of the range of document library file entry types (not inclusive)
332            * @return the range of matching document library file entry types
333            */
334            public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid,
335                    long companyId, int start, int end) {
336                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
337            }
338    
339            /**
340            * Returns an ordered range of all the document library file entry types where uuid = &#63; and companyId = &#63;.
341            *
342            * <p>
343            * 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 DLFileEntryTypeModelImpl}. 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.
344            * </p>
345            *
346            * @param uuid the uuid
347            * @param companyId the company ID
348            * @param start the lower bound of the range of document library file entry types
349            * @param end the upper bound of the range of document library file entry types (not inclusive)
350            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
351            * @return the ordered range of matching document library file entry types
352            */
353            public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid,
354                    long companyId, int start, int end,
355                    OrderByComparator<DLFileEntryType> orderByComparator) {
356                    return getPersistence()
357                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
358            }
359    
360            /**
361            * Returns the first document library file entry type in the ordered set where uuid = &#63; and companyId = &#63;.
362            *
363            * @param uuid the uuid
364            * @param companyId the company ID
365            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
366            * @return the first matching document library file entry type
367            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
368            */
369            public static DLFileEntryType findByUuid_C_First(java.lang.String uuid,
370                    long companyId, OrderByComparator<DLFileEntryType> orderByComparator)
371                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
372                    return getPersistence()
373                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
374            }
375    
376            /**
377            * Returns the first document library file entry type in the ordered set where uuid = &#63; and companyId = &#63;.
378            *
379            * @param uuid the uuid
380            * @param companyId the company ID
381            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
382            * @return the first matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
383            */
384            public static DLFileEntryType fetchByUuid_C_First(java.lang.String uuid,
385                    long companyId, OrderByComparator<DLFileEntryType> orderByComparator) {
386                    return getPersistence()
387                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
388            }
389    
390            /**
391            * Returns the last document library file entry type in the ordered set where uuid = &#63; and companyId = &#63;.
392            *
393            * @param uuid the uuid
394            * @param companyId the company ID
395            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
396            * @return the last matching document library file entry type
397            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
398            */
399            public static DLFileEntryType findByUuid_C_Last(java.lang.String uuid,
400                    long companyId, OrderByComparator<DLFileEntryType> orderByComparator)
401                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
402                    return getPersistence()
403                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
404            }
405    
406            /**
407            * Returns the last document library file entry type in the ordered set where uuid = &#63; and companyId = &#63;.
408            *
409            * @param uuid the uuid
410            * @param companyId the company ID
411            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
412            * @return the last matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
413            */
414            public static DLFileEntryType fetchByUuid_C_Last(java.lang.String uuid,
415                    long companyId, OrderByComparator<DLFileEntryType> orderByComparator) {
416                    return getPersistence()
417                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
418            }
419    
420            /**
421            * Returns the document library file entry types before and after the current document library file entry type in the ordered set where uuid = &#63; and companyId = &#63;.
422            *
423            * @param fileEntryTypeId the primary key of the current document library file entry type
424            * @param uuid the uuid
425            * @param companyId the company ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the previous, current, and next document library file entry type
428            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
429            */
430            public static DLFileEntryType[] findByUuid_C_PrevAndNext(
431                    long fileEntryTypeId, java.lang.String uuid, long companyId,
432                    OrderByComparator<DLFileEntryType> orderByComparator)
433                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
434                    return getPersistence()
435                                       .findByUuid_C_PrevAndNext(fileEntryTypeId, uuid, companyId,
436                            orderByComparator);
437            }
438    
439            /**
440            * Removes all the document library file entry types where uuid = &#63; and companyId = &#63; from the database.
441            *
442            * @param uuid the uuid
443            * @param companyId the company ID
444            */
445            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
446                    getPersistence().removeByUuid_C(uuid, companyId);
447            }
448    
449            /**
450            * Returns the number of document library file entry types where uuid = &#63; and companyId = &#63;.
451            *
452            * @param uuid the uuid
453            * @param companyId the company ID
454            * @return the number of matching document library file entry types
455            */
456            public static int countByUuid_C(java.lang.String uuid, long companyId) {
457                    return getPersistence().countByUuid_C(uuid, companyId);
458            }
459    
460            /**
461            * Returns all the document library file entry types where groupId = &#63;.
462            *
463            * @param groupId the group ID
464            * @return the matching document library file entry types
465            */
466            public static List<DLFileEntryType> findByGroupId(long groupId) {
467                    return getPersistence().findByGroupId(groupId);
468            }
469    
470            /**
471            * Returns a range of all the document library file entry types where groupId = &#63;.
472            *
473            * <p>
474            * 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 DLFileEntryTypeModelImpl}. 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.
475            * </p>
476            *
477            * @param groupId the group ID
478            * @param start the lower bound of the range of document library file entry types
479            * @param end the upper bound of the range of document library file entry types (not inclusive)
480            * @return the range of matching document library file entry types
481            */
482            public static List<DLFileEntryType> findByGroupId(long groupId, int start,
483                    int end) {
484                    return getPersistence().findByGroupId(groupId, start, end);
485            }
486    
487            /**
488            * Returns an ordered range of all the document library file entry types where groupId = &#63;.
489            *
490            * <p>
491            * 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 DLFileEntryTypeModelImpl}. 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.
492            * </p>
493            *
494            * @param groupId the group ID
495            * @param start the lower bound of the range of document library file entry types
496            * @param end the upper bound of the range of document library file entry types (not inclusive)
497            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
498            * @return the ordered range of matching document library file entry types
499            */
500            public static List<DLFileEntryType> findByGroupId(long groupId, int start,
501                    int end, OrderByComparator<DLFileEntryType> orderByComparator) {
502                    return getPersistence()
503                                       .findByGroupId(groupId, start, end, orderByComparator);
504            }
505    
506            /**
507            * Returns the first document library file entry type in the ordered set where groupId = &#63;.
508            *
509            * @param groupId the group ID
510            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
511            * @return the first matching document library file entry type
512            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
513            */
514            public static DLFileEntryType findByGroupId_First(long groupId,
515                    OrderByComparator<DLFileEntryType> orderByComparator)
516                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
517                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
518            }
519    
520            /**
521            * Returns the first document library file entry type in the ordered set where groupId = &#63;.
522            *
523            * @param groupId the group ID
524            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
525            * @return the first matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
526            */
527            public static DLFileEntryType fetchByGroupId_First(long groupId,
528                    OrderByComparator<DLFileEntryType> orderByComparator) {
529                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
530            }
531    
532            /**
533            * Returns the last document library file entry type in the ordered set where groupId = &#63;.
534            *
535            * @param groupId the group ID
536            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
537            * @return the last matching document library file entry type
538            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
539            */
540            public static DLFileEntryType findByGroupId_Last(long groupId,
541                    OrderByComparator<DLFileEntryType> orderByComparator)
542                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
543                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
544            }
545    
546            /**
547            * Returns the last document library file entry type in the ordered set where groupId = &#63;.
548            *
549            * @param groupId the group ID
550            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
551            * @return the last matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
552            */
553            public static DLFileEntryType fetchByGroupId_Last(long groupId,
554                    OrderByComparator<DLFileEntryType> orderByComparator) {
555                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
556            }
557    
558            /**
559            * Returns the document library file entry types before and after the current document library file entry type in the ordered set where groupId = &#63;.
560            *
561            * @param fileEntryTypeId the primary key of the current document library file entry type
562            * @param groupId the group ID
563            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
564            * @return the previous, current, and next document library file entry type
565            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
566            */
567            public static DLFileEntryType[] findByGroupId_PrevAndNext(
568                    long fileEntryTypeId, long groupId,
569                    OrderByComparator<DLFileEntryType> orderByComparator)
570                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
571                    return getPersistence()
572                                       .findByGroupId_PrevAndNext(fileEntryTypeId, groupId,
573                            orderByComparator);
574            }
575    
576            /**
577            * Returns all the document library file entry types that the user has permission to view where groupId = &#63;.
578            *
579            * @param groupId the group ID
580            * @return the matching document library file entry types that the user has permission to view
581            */
582            public static List<DLFileEntryType> filterFindByGroupId(long groupId) {
583                    return getPersistence().filterFindByGroupId(groupId);
584            }
585    
586            /**
587            * Returns a range of all the document library file entry types that the user has permission to view where groupId = &#63;.
588            *
589            * <p>
590            * 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 DLFileEntryTypeModelImpl}. 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.
591            * </p>
592            *
593            * @param groupId the group ID
594            * @param start the lower bound of the range of document library file entry types
595            * @param end the upper bound of the range of document library file entry types (not inclusive)
596            * @return the range of matching document library file entry types that the user has permission to view
597            */
598            public static List<DLFileEntryType> filterFindByGroupId(long groupId,
599                    int start, int end) {
600                    return getPersistence().filterFindByGroupId(groupId, start, end);
601            }
602    
603            /**
604            * Returns an ordered range of all the document library file entry types that the user has permissions to view where groupId = &#63;.
605            *
606            * <p>
607            * 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 DLFileEntryTypeModelImpl}. 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.
608            * </p>
609            *
610            * @param groupId the group ID
611            * @param start the lower bound of the range of document library file entry types
612            * @param end the upper bound of the range of document library file entry types (not inclusive)
613            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
614            * @return the ordered range of matching document library file entry types that the user has permission to view
615            */
616            public static List<DLFileEntryType> filterFindByGroupId(long groupId,
617                    int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) {
618                    return getPersistence()
619                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
620            }
621    
622            /**
623            * Returns the document library file entry types before and after the current document library file entry type in the ordered set of document library file entry types that the user has permission to view where groupId = &#63;.
624            *
625            * @param fileEntryTypeId the primary key of the current document library file entry type
626            * @param groupId the group ID
627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
628            * @return the previous, current, and next document library file entry type
629            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
630            */
631            public static DLFileEntryType[] filterFindByGroupId_PrevAndNext(
632                    long fileEntryTypeId, long groupId,
633                    OrderByComparator<DLFileEntryType> orderByComparator)
634                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
635                    return getPersistence()
636                                       .filterFindByGroupId_PrevAndNext(fileEntryTypeId, groupId,
637                            orderByComparator);
638            }
639    
640            /**
641            * Returns all the document library file entry types that the user has permission to view where groupId = any &#63;.
642            *
643            * @param groupIds the group IDs
644            * @return the matching document library file entry types that the user has permission to view
645            */
646            public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds) {
647                    return getPersistence().filterFindByGroupId(groupIds);
648            }
649    
650            /**
651            * Returns a range of all the document library file entry types that the user has permission to view where groupId = any &#63;.
652            *
653            * <p>
654            * 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 DLFileEntryTypeModelImpl}. 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.
655            * </p>
656            *
657            * @param groupIds the group IDs
658            * @param start the lower bound of the range of document library file entry types
659            * @param end the upper bound of the range of document library file entry types (not inclusive)
660            * @return the range of matching document library file entry types that the user has permission to view
661            */
662            public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds,
663                    int start, int end) {
664                    return getPersistence().filterFindByGroupId(groupIds, start, end);
665            }
666    
667            /**
668            * Returns an ordered range of all the document library file entry types that the user has permission to view where groupId = any &#63;.
669            *
670            * <p>
671            * 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 DLFileEntryTypeModelImpl}. 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.
672            * </p>
673            *
674            * @param groupIds the group IDs
675            * @param start the lower bound of the range of document library file entry types
676            * @param end the upper bound of the range of document library file entry types (not inclusive)
677            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
678            * @return the ordered range of matching document library file entry types that the user has permission to view
679            */
680            public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds,
681                    int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) {
682                    return getPersistence()
683                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
684            }
685    
686            /**
687            * Returns all the document library file entry types where groupId = any &#63;.
688            *
689            * <p>
690            * 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 DLFileEntryTypeModelImpl}. 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.
691            * </p>
692            *
693            * @param groupIds the group IDs
694            * @return the matching document library file entry types
695            */
696            public static List<DLFileEntryType> findByGroupId(long[] groupIds) {
697                    return getPersistence().findByGroupId(groupIds);
698            }
699    
700            /**
701            * Returns a range of all the document library file entry types where groupId = any &#63;.
702            *
703            * <p>
704            * 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 DLFileEntryTypeModelImpl}. 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.
705            * </p>
706            *
707            * @param groupIds the group IDs
708            * @param start the lower bound of the range of document library file entry types
709            * @param end the upper bound of the range of document library file entry types (not inclusive)
710            * @return the range of matching document library file entry types
711            */
712            public static List<DLFileEntryType> findByGroupId(long[] groupIds,
713                    int start, int end) {
714                    return getPersistence().findByGroupId(groupIds, start, end);
715            }
716    
717            /**
718            * Returns an ordered range of all the document library file entry types where groupId = any &#63;.
719            *
720            * <p>
721            * 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 DLFileEntryTypeModelImpl}. 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.
722            * </p>
723            *
724            * @param groupIds the group IDs
725            * @param start the lower bound of the range of document library file entry types
726            * @param end the upper bound of the range of document library file entry types (not inclusive)
727            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
728            * @return the ordered range of matching document library file entry types
729            */
730            public static List<DLFileEntryType> findByGroupId(long[] groupIds,
731                    int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) {
732                    return getPersistence()
733                                       .findByGroupId(groupIds, start, end, orderByComparator);
734            }
735    
736            /**
737            * Removes all the document library file entry types where groupId = &#63; from the database.
738            *
739            * @param groupId the group ID
740            */
741            public static void removeByGroupId(long groupId) {
742                    getPersistence().removeByGroupId(groupId);
743            }
744    
745            /**
746            * Returns the number of document library file entry types where groupId = &#63;.
747            *
748            * @param groupId the group ID
749            * @return the number of matching document library file entry types
750            */
751            public static int countByGroupId(long groupId) {
752                    return getPersistence().countByGroupId(groupId);
753            }
754    
755            /**
756            * Returns the number of document library file entry types where groupId = any &#63;.
757            *
758            * @param groupIds the group IDs
759            * @return the number of matching document library file entry types
760            */
761            public static int countByGroupId(long[] groupIds) {
762                    return getPersistence().countByGroupId(groupIds);
763            }
764    
765            /**
766            * Returns the number of document library file entry types that the user has permission to view where groupId = &#63;.
767            *
768            * @param groupId the group ID
769            * @return the number of matching document library file entry types that the user has permission to view
770            */
771            public static int filterCountByGroupId(long groupId) {
772                    return getPersistence().filterCountByGroupId(groupId);
773            }
774    
775            /**
776            * Returns the number of document library file entry types that the user has permission to view where groupId = any &#63;.
777            *
778            * @param groupIds the group IDs
779            * @return the number of matching document library file entry types that the user has permission to view
780            */
781            public static int filterCountByGroupId(long[] groupIds) {
782                    return getPersistence().filterCountByGroupId(groupIds);
783            }
784    
785            /**
786            * Returns the document library file entry type where groupId = &#63; and fileEntryTypeKey = &#63; or throws a {@link NoSuchFileEntryTypeException} if it could not be found.
787            *
788            * @param groupId the group ID
789            * @param fileEntryTypeKey the file entry type key
790            * @return the matching document library file entry type
791            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
792            */
793            public static DLFileEntryType findByG_F(long groupId,
794                    java.lang.String fileEntryTypeKey)
795                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
796                    return getPersistence().findByG_F(groupId, fileEntryTypeKey);
797            }
798    
799            /**
800            * Returns the document library file entry type where groupId = &#63; and fileEntryTypeKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
801            *
802            * @param groupId the group ID
803            * @param fileEntryTypeKey the file entry type key
804            * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
805            */
806            public static DLFileEntryType fetchByG_F(long groupId,
807                    java.lang.String fileEntryTypeKey) {
808                    return getPersistence().fetchByG_F(groupId, fileEntryTypeKey);
809            }
810    
811            /**
812            * Returns the document library file entry type where groupId = &#63; and fileEntryTypeKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
813            *
814            * @param groupId the group ID
815            * @param fileEntryTypeKey the file entry type key
816            * @param retrieveFromCache whether to use the finder cache
817            * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
818            */
819            public static DLFileEntryType fetchByG_F(long groupId,
820                    java.lang.String fileEntryTypeKey, boolean retrieveFromCache) {
821                    return getPersistence()
822                                       .fetchByG_F(groupId, fileEntryTypeKey, retrieveFromCache);
823            }
824    
825            /**
826            * Removes the document library file entry type where groupId = &#63; and fileEntryTypeKey = &#63; from the database.
827            *
828            * @param groupId the group ID
829            * @param fileEntryTypeKey the file entry type key
830            * @return the document library file entry type that was removed
831            */
832            public static DLFileEntryType removeByG_F(long groupId,
833                    java.lang.String fileEntryTypeKey)
834                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
835                    return getPersistence().removeByG_F(groupId, fileEntryTypeKey);
836            }
837    
838            /**
839            * Returns the number of document library file entry types where groupId = &#63; and fileEntryTypeKey = &#63;.
840            *
841            * @param groupId the group ID
842            * @param fileEntryTypeKey the file entry type key
843            * @return the number of matching document library file entry types
844            */
845            public static int countByG_F(long groupId, java.lang.String fileEntryTypeKey) {
846                    return getPersistence().countByG_F(groupId, fileEntryTypeKey);
847            }
848    
849            /**
850            * Caches the document library file entry type in the entity cache if it is enabled.
851            *
852            * @param dlFileEntryType the document library file entry type
853            */
854            public static void cacheResult(DLFileEntryType dlFileEntryType) {
855                    getPersistence().cacheResult(dlFileEntryType);
856            }
857    
858            /**
859            * Caches the document library file entry types in the entity cache if it is enabled.
860            *
861            * @param dlFileEntryTypes the document library file entry types
862            */
863            public static void cacheResult(List<DLFileEntryType> dlFileEntryTypes) {
864                    getPersistence().cacheResult(dlFileEntryTypes);
865            }
866    
867            /**
868            * Creates a new document library file entry type with the primary key. Does not add the document library file entry type to the database.
869            *
870            * @param fileEntryTypeId the primary key for the new document library file entry type
871            * @return the new document library file entry type
872            */
873            public static DLFileEntryType create(long fileEntryTypeId) {
874                    return getPersistence().create(fileEntryTypeId);
875            }
876    
877            /**
878            * Removes the document library file entry type with the primary key from the database. Also notifies the appropriate model listeners.
879            *
880            * @param fileEntryTypeId the primary key of the document library file entry type
881            * @return the document library file entry type that was removed
882            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
883            */
884            public static DLFileEntryType remove(long fileEntryTypeId)
885                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
886                    return getPersistence().remove(fileEntryTypeId);
887            }
888    
889            public static DLFileEntryType updateImpl(DLFileEntryType dlFileEntryType) {
890                    return getPersistence().updateImpl(dlFileEntryType);
891            }
892    
893            /**
894            * Returns the document library file entry type with the primary key or throws a {@link NoSuchFileEntryTypeException} if it could not be found.
895            *
896            * @param fileEntryTypeId the primary key of the document library file entry type
897            * @return the document library file entry type
898            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
899            */
900            public static DLFileEntryType findByPrimaryKey(long fileEntryTypeId)
901                    throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException {
902                    return getPersistence().findByPrimaryKey(fileEntryTypeId);
903            }
904    
905            /**
906            * Returns the document library file entry type with the primary key or returns <code>null</code> if it could not be found.
907            *
908            * @param fileEntryTypeId the primary key of the document library file entry type
909            * @return the document library file entry type, or <code>null</code> if a document library file entry type with the primary key could not be found
910            */
911            public static DLFileEntryType fetchByPrimaryKey(long fileEntryTypeId) {
912                    return getPersistence().fetchByPrimaryKey(fileEntryTypeId);
913            }
914    
915            public static java.util.Map<java.io.Serializable, DLFileEntryType> fetchByPrimaryKeys(
916                    java.util.Set<java.io.Serializable> primaryKeys) {
917                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
918            }
919    
920            /**
921            * Returns all the document library file entry types.
922            *
923            * @return the document library file entry types
924            */
925            public static List<DLFileEntryType> findAll() {
926                    return getPersistence().findAll();
927            }
928    
929            /**
930            * Returns a range of all the document library file entry types.
931            *
932            * <p>
933            * 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 DLFileEntryTypeModelImpl}. 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.
934            * </p>
935            *
936            * @param start the lower bound of the range of document library file entry types
937            * @param end the upper bound of the range of document library file entry types (not inclusive)
938            * @return the range of document library file entry types
939            */
940            public static List<DLFileEntryType> findAll(int start, int end) {
941                    return getPersistence().findAll(start, end);
942            }
943    
944            /**
945            * Returns an ordered range of all the document library file entry types.
946            *
947            * <p>
948            * 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 DLFileEntryTypeModelImpl}. 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.
949            * </p>
950            *
951            * @param start the lower bound of the range of document library file entry types
952            * @param end the upper bound of the range of document library file entry types (not inclusive)
953            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
954            * @return the ordered range of document library file entry types
955            */
956            public static List<DLFileEntryType> findAll(int start, int end,
957                    OrderByComparator<DLFileEntryType> orderByComparator) {
958                    return getPersistence().findAll(start, end, orderByComparator);
959            }
960    
961            /**
962            * Removes all the document library file entry types from the database.
963            */
964            public static void removeAll() {
965                    getPersistence().removeAll();
966            }
967    
968            /**
969            * Returns the number of document library file entry types.
970            *
971            * @return the number of document library file entry types
972            */
973            public static int countAll() {
974                    return getPersistence().countAll();
975            }
976    
977            /**
978            * Returns the primaryKeys of document library folders associated with the document library file entry type.
979            *
980            * @param pk the primary key of the document library file entry type
981            * @return long[] of the primaryKeys of document library folders associated with the document library file entry type
982            */
983            public static long[] getDLFolderPrimaryKeys(long pk) {
984                    return getPersistence().getDLFolderPrimaryKeys(pk);
985            }
986    
987            /**
988            * Returns all the document library folders associated with the document library file entry type.
989            *
990            * @param pk the primary key of the document library file entry type
991            * @return the document library folders associated with the document library file entry type
992            */
993            public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders(
994                    long pk) {
995                    return getPersistence().getDLFolders(pk);
996            }
997    
998            /**
999            * Returns a range of all the document library folders associated with the document library file entry type.
1000            *
1001            * <p>
1002            * 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 DLFileEntryTypeModelImpl}. 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.
1003            * </p>
1004            *
1005            * @param pk the primary key of the document library file entry type
1006            * @param start the lower bound of the range of document library file entry types
1007            * @param end the upper bound of the range of document library file entry types (not inclusive)
1008            * @return the range of document library folders associated with the document library file entry type
1009            */
1010            public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders(
1011                    long pk, int start, int end) {
1012                    return getPersistence().getDLFolders(pk, start, end);
1013            }
1014    
1015            /**
1016            * Returns an ordered range of all the document library folders associated with the document library file entry type.
1017            *
1018            * <p>
1019            * 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 DLFileEntryTypeModelImpl}. 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.
1020            * </p>
1021            *
1022            * @param pk the primary key of the document library file entry type
1023            * @param start the lower bound of the range of document library file entry types
1024            * @param end the upper bound of the range of document library file entry types (not inclusive)
1025            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1026            * @return the ordered range of document library folders associated with the document library file entry type
1027            */
1028            public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders(
1029                    long pk, int start, int end,
1030                    OrderByComparator<com.liferay.portlet.documentlibrary.model.DLFolder> orderByComparator) {
1031                    return getPersistence().getDLFolders(pk, start, end, orderByComparator);
1032            }
1033    
1034            /**
1035            * Returns the number of document library folders associated with the document library file entry type.
1036            *
1037            * @param pk the primary key of the document library file entry type
1038            * @return the number of document library folders associated with the document library file entry type
1039            */
1040            public static int getDLFoldersSize(long pk) {
1041                    return getPersistence().getDLFoldersSize(pk);
1042            }
1043    
1044            /**
1045            * Returns <code>true</code> if the document library folder is associated with the document library file entry type.
1046            *
1047            * @param pk the primary key of the document library file entry type
1048            * @param dlFolderPK the primary key of the document library folder
1049            * @return <code>true</code> if the document library folder is associated with the document library file entry type; <code>false</code> otherwise
1050            */
1051            public static boolean containsDLFolder(long pk, long dlFolderPK) {
1052                    return getPersistence().containsDLFolder(pk, dlFolderPK);
1053            }
1054    
1055            /**
1056            * Returns <code>true</code> if the document library file entry type has any document library folders associated with it.
1057            *
1058            * @param pk the primary key of the document library file entry type to check for associations with document library folders
1059            * @return <code>true</code> if the document library file entry type has any document library folders associated with it; <code>false</code> otherwise
1060            */
1061            public static boolean containsDLFolders(long pk) {
1062                    return getPersistence().containsDLFolders(pk);
1063            }
1064    
1065            /**
1066            * Adds an association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1067            *
1068            * @param pk the primary key of the document library file entry type
1069            * @param dlFolderPK the primary key of the document library folder
1070            */
1071            public static void addDLFolder(long pk, long dlFolderPK) {
1072                    getPersistence().addDLFolder(pk, dlFolderPK);
1073            }
1074    
1075            /**
1076            * Adds an association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1077            *
1078            * @param pk the primary key of the document library file entry type
1079            * @param dlFolder the document library folder
1080            */
1081            public static void addDLFolder(long pk,
1082                    com.liferay.portlet.documentlibrary.model.DLFolder dlFolder) {
1083                    getPersistence().addDLFolder(pk, dlFolder);
1084            }
1085    
1086            /**
1087            * Adds an association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1088            *
1089            * @param pk the primary key of the document library file entry type
1090            * @param dlFolderPKs the primary keys of the document library folders
1091            */
1092            public static void addDLFolders(long pk, long[] dlFolderPKs) {
1093                    getPersistence().addDLFolders(pk, dlFolderPKs);
1094            }
1095    
1096            /**
1097            * Adds an association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1098            *
1099            * @param pk the primary key of the document library file entry type
1100            * @param dlFolders the document library folders
1101            */
1102            public static void addDLFolders(long pk,
1103                    List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) {
1104                    getPersistence().addDLFolders(pk, dlFolders);
1105            }
1106    
1107            /**
1108            * Clears all associations between the document library file entry type and its document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1109            *
1110            * @param pk the primary key of the document library file entry type to clear the associated document library folders from
1111            */
1112            public static void clearDLFolders(long pk) {
1113                    getPersistence().clearDLFolders(pk);
1114            }
1115    
1116            /**
1117            * Removes the association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1118            *
1119            * @param pk the primary key of the document library file entry type
1120            * @param dlFolderPK the primary key of the document library folder
1121            */
1122            public static void removeDLFolder(long pk, long dlFolderPK) {
1123                    getPersistence().removeDLFolder(pk, dlFolderPK);
1124            }
1125    
1126            /**
1127            * Removes the association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1128            *
1129            * @param pk the primary key of the document library file entry type
1130            * @param dlFolder the document library folder
1131            */
1132            public static void removeDLFolder(long pk,
1133                    com.liferay.portlet.documentlibrary.model.DLFolder dlFolder) {
1134                    getPersistence().removeDLFolder(pk, dlFolder);
1135            }
1136    
1137            /**
1138            * Removes the association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1139            *
1140            * @param pk the primary key of the document library file entry type
1141            * @param dlFolderPKs the primary keys of the document library folders
1142            */
1143            public static void removeDLFolders(long pk, long[] dlFolderPKs) {
1144                    getPersistence().removeDLFolders(pk, dlFolderPKs);
1145            }
1146    
1147            /**
1148            * Removes the association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1149            *
1150            * @param pk the primary key of the document library file entry type
1151            * @param dlFolders the document library folders
1152            */
1153            public static void removeDLFolders(long pk,
1154                    List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) {
1155                    getPersistence().removeDLFolders(pk, dlFolders);
1156            }
1157    
1158            /**
1159            * Sets the document library folders associated with the document library file entry type, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1160            *
1161            * @param pk the primary key of the document library file entry type
1162            * @param dlFolderPKs the primary keys of the document library folders to be associated with the document library file entry type
1163            */
1164            public static void setDLFolders(long pk, long[] dlFolderPKs) {
1165                    getPersistence().setDLFolders(pk, dlFolderPKs);
1166            }
1167    
1168            /**
1169            * Sets the document library folders associated with the document library file entry type, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1170            *
1171            * @param pk the primary key of the document library file entry type
1172            * @param dlFolders the document library folders to be associated with the document library file entry type
1173            */
1174            public static void setDLFolders(long pk,
1175                    List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) {
1176                    getPersistence().setDLFolders(pk, dlFolders);
1177            }
1178    
1179            /**
1180            * Returns the primaryKeys of d d m structures associated with the document library file entry type.
1181            *
1182            * @param pk the primary key of the document library file entry type
1183            * @return long[] of the primaryKeys of d d m structures associated with the document library file entry type
1184            */
1185            public static long[] getDDMStructurePrimaryKeys(long pk) {
1186                    return getPersistence().getDDMStructurePrimaryKeys(pk);
1187            }
1188    
1189            /**
1190            * Returns all the d d m structures associated with the document library file entry type.
1191            *
1192            * @param pk the primary key of the document library file entry type
1193            * @return the d d m structures associated with the document library file entry type
1194            */
1195            public static List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures(
1196                    long pk) {
1197                    return getPersistence().getDDMStructures(pk);
1198            }
1199    
1200            /**
1201            * Returns a range of all the d d m structures associated with the document library file entry type.
1202            *
1203            * <p>
1204            * 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 DLFileEntryTypeModelImpl}. 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.
1205            * </p>
1206            *
1207            * @param pk the primary key of the document library file entry type
1208            * @param start the lower bound of the range of document library file entry types
1209            * @param end the upper bound of the range of document library file entry types (not inclusive)
1210            * @return the range of d d m structures associated with the document library file entry type
1211            */
1212            public static List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures(
1213                    long pk, int start, int end) {
1214                    return getPersistence().getDDMStructures(pk, start, end);
1215            }
1216    
1217            /**
1218            * Returns an ordered range of all the d d m structures associated with the document library file entry type.
1219            *
1220            * <p>
1221            * 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 DLFileEntryTypeModelImpl}. 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.
1222            * </p>
1223            *
1224            * @param pk the primary key of the document library file entry type
1225            * @param start the lower bound of the range of document library file entry types
1226            * @param end the upper bound of the range of document library file entry types (not inclusive)
1227            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1228            * @return the ordered range of d d m structures associated with the document library file entry type
1229            */
1230            public static List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures(
1231                    long pk, int start, int end,
1232                    OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
1233                    return getPersistence()
1234                                       .getDDMStructures(pk, start, end, orderByComparator);
1235            }
1236    
1237            /**
1238            * Returns the number of d d m structures associated with the document library file entry type.
1239            *
1240            * @param pk the primary key of the document library file entry type
1241            * @return the number of d d m structures associated with the document library file entry type
1242            */
1243            public static int getDDMStructuresSize(long pk) {
1244                    return getPersistence().getDDMStructuresSize(pk);
1245            }
1246    
1247            /**
1248            * Returns <code>true</code> if the d d m structure is associated with the document library file entry type.
1249            *
1250            * @param pk the primary key of the document library file entry type
1251            * @param ddmStructurePK the primary key of the d d m structure
1252            * @return <code>true</code> if the d d m structure is associated with the document library file entry type; <code>false</code> otherwise
1253            */
1254            public static boolean containsDDMStructure(long pk, long ddmStructurePK) {
1255                    return getPersistence().containsDDMStructure(pk, ddmStructurePK);
1256            }
1257    
1258            /**
1259            * Returns <code>true</code> if the document library file entry type has any d d m structures associated with it.
1260            *
1261            * @param pk the primary key of the document library file entry type to check for associations with d d m structures
1262            * @return <code>true</code> if the document library file entry type has any d d m structures associated with it; <code>false</code> otherwise
1263            */
1264            public static boolean containsDDMStructures(long pk) {
1265                    return getPersistence().containsDDMStructures(pk);
1266            }
1267    
1268            /**
1269            * Adds an association between the document library file entry type and the d d m structure. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1270            *
1271            * @param pk the primary key of the document library file entry type
1272            * @param ddmStructurePK the primary key of the d d m structure
1273            */
1274            public static void addDDMStructure(long pk, long ddmStructurePK) {
1275                    getPersistence().addDDMStructure(pk, ddmStructurePK);
1276            }
1277    
1278            /**
1279            * Adds an association between the document library file entry type and the d d m structure. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1280            *
1281            * @param pk the primary key of the document library file entry type
1282            * @param ddmStructure the d d m structure
1283            */
1284            public static void addDDMStructure(long pk,
1285                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
1286                    getPersistence().addDDMStructure(pk, ddmStructure);
1287            }
1288    
1289            /**
1290            * Adds an association between the document library file entry type and the d d m structures. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1291            *
1292            * @param pk the primary key of the document library file entry type
1293            * @param ddmStructurePKs the primary keys of the d d m structures
1294            */
1295            public static void addDDMStructures(long pk, long[] ddmStructurePKs) {
1296                    getPersistence().addDDMStructures(pk, ddmStructurePKs);
1297            }
1298    
1299            /**
1300            * Adds an association between the document library file entry type and the d d m structures. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1301            *
1302            * @param pk the primary key of the document library file entry type
1303            * @param ddmStructures the d d m structures
1304            */
1305            public static void addDDMStructures(long pk,
1306                    List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures) {
1307                    getPersistence().addDDMStructures(pk, ddmStructures);
1308            }
1309    
1310            /**
1311            * Clears all associations between the document library file entry type and its d d m structures. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1312            *
1313            * @param pk the primary key of the document library file entry type to clear the associated d d m structures from
1314            */
1315            public static void clearDDMStructures(long pk) {
1316                    getPersistence().clearDDMStructures(pk);
1317            }
1318    
1319            /**
1320            * Removes the association between the document library file entry type and the d d m structure. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1321            *
1322            * @param pk the primary key of the document library file entry type
1323            * @param ddmStructurePK the primary key of the d d m structure
1324            */
1325            public static void removeDDMStructure(long pk, long ddmStructurePK) {
1326                    getPersistence().removeDDMStructure(pk, ddmStructurePK);
1327            }
1328    
1329            /**
1330            * Removes the association between the document library file entry type and the d d m structure. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1331            *
1332            * @param pk the primary key of the document library file entry type
1333            * @param ddmStructure the d d m structure
1334            */
1335            public static void removeDDMStructure(long pk,
1336                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
1337                    getPersistence().removeDDMStructure(pk, ddmStructure);
1338            }
1339    
1340            /**
1341            * Removes the association between the document library file entry type and the d d m structures. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1342            *
1343            * @param pk the primary key of the document library file entry type
1344            * @param ddmStructurePKs the primary keys of the d d m structures
1345            */
1346            public static void removeDDMStructures(long pk, long[] ddmStructurePKs) {
1347                    getPersistence().removeDDMStructures(pk, ddmStructurePKs);
1348            }
1349    
1350            /**
1351            * Removes the association between the document library file entry type and the d d m structures. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1352            *
1353            * @param pk the primary key of the document library file entry type
1354            * @param ddmStructures the d d m structures
1355            */
1356            public static void removeDDMStructures(long pk,
1357                    List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures) {
1358                    getPersistence().removeDDMStructures(pk, ddmStructures);
1359            }
1360    
1361            /**
1362            * Sets the d d m structures associated with the document library file entry type, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1363            *
1364            * @param pk the primary key of the document library file entry type
1365            * @param ddmStructurePKs the primary keys of the d d m structures to be associated with the document library file entry type
1366            */
1367            public static void setDDMStructures(long pk, long[] ddmStructurePKs) {
1368                    getPersistence().setDDMStructures(pk, ddmStructurePKs);
1369            }
1370    
1371            /**
1372            * Sets the d d m structures associated with the document library file entry type, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1373            *
1374            * @param pk the primary key of the document library file entry type
1375            * @param ddmStructures the d d m structures to be associated with the document library file entry type
1376            */
1377            public static void setDDMStructures(long pk,
1378                    List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures) {
1379                    getPersistence().setDDMStructures(pk, ddmStructures);
1380            }
1381    
1382            public static DLFileEntryTypePersistence getPersistence() {
1383                    if (_persistence == null) {
1384                            _persistence = (DLFileEntryTypePersistence)PortalBeanLocatorUtil.locate(DLFileEntryTypePersistence.class.getName());
1385    
1386                            ReferenceRegistry.registerReference(DLFileEntryTypeUtil.class,
1387                                    "_persistence");
1388                    }
1389    
1390                    return _persistence;
1391            }
1392    
1393            /**
1394             * @deprecated As of 6.2.0
1395             */
1396            @Deprecated
1397            public void setPersistence(DLFileEntryTypePersistence persistence) {
1398            }
1399    
1400            private static DLFileEntryTypePersistence _persistence;
1401    }