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.DLFileVersion;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the document library file version service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileVersionPersistenceImpl} 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 DLFileVersionPersistence
038     * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileVersionPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class DLFileVersionUtil {
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(DLFileVersion dlFileVersion) {
060                    getPersistence().clearCache(dlFileVersion);
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<DLFileVersion> 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<DLFileVersion> 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<DLFileVersion> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<DLFileVersion> 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 DLFileVersion update(DLFileVersion dlFileVersion) {
101                    return getPersistence().update(dlFileVersion);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static DLFileVersion update(DLFileVersion dlFileVersion,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(dlFileVersion, serviceContext);
110            }
111    
112            /**
113            * Returns all the document library file versions where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching document library file versions
117            */
118            public static List<DLFileVersion> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the document library file versions 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 DLFileVersionModelImpl}. 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 versions
131            * @param end the upper bound of the range of document library file versions (not inclusive)
132            * @return the range of matching document library file versions
133            */
134            public static List<DLFileVersion> 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 versions 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 DLFileVersionModelImpl}. 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 versions
148            * @param end the upper bound of the range of document library file versions (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 versions
151            */
152            public static List<DLFileVersion> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first document library file version 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 version
163            * @throws NoSuchFileVersionException if a matching document library file version could not be found
164            */
165            public static DLFileVersion findByUuid_First(java.lang.String uuid,
166                    OrderByComparator<DLFileVersion> orderByComparator)
167                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
168                    return getPersistence().findByUuid_First(uuid, orderByComparator);
169            }
170    
171            /**
172            * Returns the first document library file version 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 version, or <code>null</code> if a matching document library file version could not be found
177            */
178            public static DLFileVersion fetchByUuid_First(java.lang.String uuid,
179                    OrderByComparator<DLFileVersion> orderByComparator) {
180                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the last document library file version 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 version
189            * @throws NoSuchFileVersionException if a matching document library file version could not be found
190            */
191            public static DLFileVersion findByUuid_Last(java.lang.String uuid,
192                    OrderByComparator<DLFileVersion> orderByComparator)
193                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
194                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last document library file version 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 version, or <code>null</code> if a matching document library file version could not be found
203            */
204            public static DLFileVersion fetchByUuid_Last(java.lang.String uuid,
205                    OrderByComparator<DLFileVersion> orderByComparator) {
206                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
207            }
208    
209            /**
210            * Returns the document library file versions before and after the current document library file version in the ordered set where uuid = &#63;.
211            *
212            * @param fileVersionId the primary key of the current document library file version
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 version
216            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
217            */
218            public static DLFileVersion[] findByUuid_PrevAndNext(long fileVersionId,
219                    java.lang.String uuid,
220                    OrderByComparator<DLFileVersion> orderByComparator)
221                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
222                    return getPersistence()
223                                       .findByUuid_PrevAndNext(fileVersionId, uuid,
224                            orderByComparator);
225            }
226    
227            /**
228            * Removes all the document library file versions 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 versions where uuid = &#63;.
238            *
239            * @param uuid the uuid
240            * @return the number of matching document library file versions
241            */
242            public static int countByUuid(java.lang.String uuid) {
243                    return getPersistence().countByUuid(uuid);
244            }
245    
246            /**
247            * Returns the document library file version where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchFileVersionException} 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 version
252            * @throws NoSuchFileVersionException if a matching document library file version could not be found
253            */
254            public static DLFileVersion findByUUID_G(java.lang.String uuid, long groupId)
255                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
256                    return getPersistence().findByUUID_G(uuid, groupId);
257            }
258    
259            /**
260            * Returns the document library file version where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
261            *
262            * @param uuid the uuid
263            * @param groupId the group ID
264            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
265            */
266            public static DLFileVersion fetchByUUID_G(java.lang.String uuid,
267                    long groupId) {
268                    return getPersistence().fetchByUUID_G(uuid, groupId);
269            }
270    
271            /**
272            * Returns the document library file version where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
273            *
274            * @param uuid the uuid
275            * @param groupId the group ID
276            * @param retrieveFromCache whether to use the finder cache
277            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
278            */
279            public static DLFileVersion fetchByUUID_G(java.lang.String uuid,
280                    long groupId, boolean retrieveFromCache) {
281                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
282            }
283    
284            /**
285            * Removes the document library file version where uuid = &#63; and groupId = &#63; from the database.
286            *
287            * @param uuid the uuid
288            * @param groupId the group ID
289            * @return the document library file version that was removed
290            */
291            public static DLFileVersion removeByUUID_G(java.lang.String uuid,
292                    long groupId)
293                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
294                    return getPersistence().removeByUUID_G(uuid, groupId);
295            }
296    
297            /**
298            * Returns the number of document library file versions where uuid = &#63; and groupId = &#63;.
299            *
300            * @param uuid the uuid
301            * @param groupId the group ID
302            * @return the number of matching document library file versions
303            */
304            public static int countByUUID_G(java.lang.String uuid, long groupId) {
305                    return getPersistence().countByUUID_G(uuid, groupId);
306            }
307    
308            /**
309            * Returns all the document library file versions where uuid = &#63; and companyId = &#63;.
310            *
311            * @param uuid the uuid
312            * @param companyId the company ID
313            * @return the matching document library file versions
314            */
315            public static List<DLFileVersion> findByUuid_C(java.lang.String uuid,
316                    long companyId) {
317                    return getPersistence().findByUuid_C(uuid, companyId);
318            }
319    
320            /**
321            * Returns a range of all the document library file versions where uuid = &#63; and companyId = &#63;.
322            *
323            * <p>
324            * 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 DLFileVersionModelImpl}. 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.
325            * </p>
326            *
327            * @param uuid the uuid
328            * @param companyId the company ID
329            * @param start the lower bound of the range of document library file versions
330            * @param end the upper bound of the range of document library file versions (not inclusive)
331            * @return the range of matching document library file versions
332            */
333            public static List<DLFileVersion> findByUuid_C(java.lang.String uuid,
334                    long companyId, int start, int end) {
335                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
336            }
337    
338            /**
339            * Returns an ordered range of all the document library file versions where uuid = &#63; and companyId = &#63;.
340            *
341            * <p>
342            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
343            * </p>
344            *
345            * @param uuid the uuid
346            * @param companyId the company ID
347            * @param start the lower bound of the range of document library file versions
348            * @param end the upper bound of the range of document library file versions (not inclusive)
349            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
350            * @return the ordered range of matching document library file versions
351            */
352            public static List<DLFileVersion> findByUuid_C(java.lang.String uuid,
353                    long companyId, int start, int end,
354                    OrderByComparator<DLFileVersion> orderByComparator) {
355                    return getPersistence()
356                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
357            }
358    
359            /**
360            * Returns the first document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
361            *
362            * @param uuid the uuid
363            * @param companyId the company ID
364            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
365            * @return the first matching document library file version
366            * @throws NoSuchFileVersionException if a matching document library file version could not be found
367            */
368            public static DLFileVersion findByUuid_C_First(java.lang.String uuid,
369                    long companyId, OrderByComparator<DLFileVersion> orderByComparator)
370                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
371                    return getPersistence()
372                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
373            }
374    
375            /**
376            * Returns the first document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
377            *
378            * @param uuid the uuid
379            * @param companyId the company ID
380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
381            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
382            */
383            public static DLFileVersion fetchByUuid_C_First(java.lang.String uuid,
384                    long companyId, OrderByComparator<DLFileVersion> orderByComparator) {
385                    return getPersistence()
386                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
387            }
388    
389            /**
390            * Returns the last document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
391            *
392            * @param uuid the uuid
393            * @param companyId the company ID
394            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
395            * @return the last matching document library file version
396            * @throws NoSuchFileVersionException if a matching document library file version could not be found
397            */
398            public static DLFileVersion findByUuid_C_Last(java.lang.String uuid,
399                    long companyId, OrderByComparator<DLFileVersion> orderByComparator)
400                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
401                    return getPersistence()
402                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
403            }
404    
405            /**
406            * Returns the last document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
407            *
408            * @param uuid the uuid
409            * @param companyId the company ID
410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
411            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
412            */
413            public static DLFileVersion fetchByUuid_C_Last(java.lang.String uuid,
414                    long companyId, OrderByComparator<DLFileVersion> orderByComparator) {
415                    return getPersistence()
416                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
417            }
418    
419            /**
420            * Returns the document library file versions before and after the current document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
421            *
422            * @param fileVersionId the primary key of the current document library file version
423            * @param uuid the uuid
424            * @param companyId the company ID
425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
426            * @return the previous, current, and next document library file version
427            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
428            */
429            public static DLFileVersion[] findByUuid_C_PrevAndNext(long fileVersionId,
430                    java.lang.String uuid, long companyId,
431                    OrderByComparator<DLFileVersion> orderByComparator)
432                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
433                    return getPersistence()
434                                       .findByUuid_C_PrevAndNext(fileVersionId, uuid, companyId,
435                            orderByComparator);
436            }
437    
438            /**
439            * Removes all the document library file versions where uuid = &#63; and companyId = &#63; from the database.
440            *
441            * @param uuid the uuid
442            * @param companyId the company ID
443            */
444            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
445                    getPersistence().removeByUuid_C(uuid, companyId);
446            }
447    
448            /**
449            * Returns the number of document library file versions where uuid = &#63; and companyId = &#63;.
450            *
451            * @param uuid the uuid
452            * @param companyId the company ID
453            * @return the number of matching document library file versions
454            */
455            public static int countByUuid_C(java.lang.String uuid, long companyId) {
456                    return getPersistence().countByUuid_C(uuid, companyId);
457            }
458    
459            /**
460            * Returns all the document library file versions where companyId = &#63;.
461            *
462            * @param companyId the company ID
463            * @return the matching document library file versions
464            */
465            public static List<DLFileVersion> findByCompanyId(long companyId) {
466                    return getPersistence().findByCompanyId(companyId);
467            }
468    
469            /**
470            * Returns a range of all the document library file versions where companyId = &#63;.
471            *
472            * <p>
473            * 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 DLFileVersionModelImpl}. 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.
474            * </p>
475            *
476            * @param companyId the company ID
477            * @param start the lower bound of the range of document library file versions
478            * @param end the upper bound of the range of document library file versions (not inclusive)
479            * @return the range of matching document library file versions
480            */
481            public static List<DLFileVersion> findByCompanyId(long companyId,
482                    int start, int end) {
483                    return getPersistence().findByCompanyId(companyId, start, end);
484            }
485    
486            /**
487            * Returns an ordered range of all the document library file versions where companyId = &#63;.
488            *
489            * <p>
490            * 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 DLFileVersionModelImpl}. 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.
491            * </p>
492            *
493            * @param companyId the company ID
494            * @param start the lower bound of the range of document library file versions
495            * @param end the upper bound of the range of document library file versions (not inclusive)
496            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
497            * @return the ordered range of matching document library file versions
498            */
499            public static List<DLFileVersion> findByCompanyId(long companyId,
500                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
501                    return getPersistence()
502                                       .findByCompanyId(companyId, start, end, orderByComparator);
503            }
504    
505            /**
506            * Returns the first document library file version in the ordered set where companyId = &#63;.
507            *
508            * @param companyId the company ID
509            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
510            * @return the first matching document library file version
511            * @throws NoSuchFileVersionException if a matching document library file version could not be found
512            */
513            public static DLFileVersion findByCompanyId_First(long companyId,
514                    OrderByComparator<DLFileVersion> orderByComparator)
515                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
516                    return getPersistence()
517                                       .findByCompanyId_First(companyId, orderByComparator);
518            }
519    
520            /**
521            * Returns the first document library file version in the ordered set where companyId = &#63;.
522            *
523            * @param companyId the company ID
524            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
525            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
526            */
527            public static DLFileVersion fetchByCompanyId_First(long companyId,
528                    OrderByComparator<DLFileVersion> orderByComparator) {
529                    return getPersistence()
530                                       .fetchByCompanyId_First(companyId, orderByComparator);
531            }
532    
533            /**
534            * Returns the last document library file version in the ordered set where companyId = &#63;.
535            *
536            * @param companyId the company ID
537            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
538            * @return the last matching document library file version
539            * @throws NoSuchFileVersionException if a matching document library file version could not be found
540            */
541            public static DLFileVersion findByCompanyId_Last(long companyId,
542                    OrderByComparator<DLFileVersion> orderByComparator)
543                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
544                    return getPersistence()
545                                       .findByCompanyId_Last(companyId, orderByComparator);
546            }
547    
548            /**
549            * Returns the last document library file version in the ordered set where companyId = &#63;.
550            *
551            * @param companyId the company ID
552            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
553            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
554            */
555            public static DLFileVersion fetchByCompanyId_Last(long companyId,
556                    OrderByComparator<DLFileVersion> orderByComparator) {
557                    return getPersistence()
558                                       .fetchByCompanyId_Last(companyId, orderByComparator);
559            }
560    
561            /**
562            * Returns the document library file versions before and after the current document library file version in the ordered set where companyId = &#63;.
563            *
564            * @param fileVersionId the primary key of the current document library file version
565            * @param companyId the company ID
566            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
567            * @return the previous, current, and next document library file version
568            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
569            */
570            public static DLFileVersion[] findByCompanyId_PrevAndNext(
571                    long fileVersionId, long companyId,
572                    OrderByComparator<DLFileVersion> orderByComparator)
573                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
574                    return getPersistence()
575                                       .findByCompanyId_PrevAndNext(fileVersionId, companyId,
576                            orderByComparator);
577            }
578    
579            /**
580            * Removes all the document library file versions where companyId = &#63; from the database.
581            *
582            * @param companyId the company ID
583            */
584            public static void removeByCompanyId(long companyId) {
585                    getPersistence().removeByCompanyId(companyId);
586            }
587    
588            /**
589            * Returns the number of document library file versions where companyId = &#63;.
590            *
591            * @param companyId the company ID
592            * @return the number of matching document library file versions
593            */
594            public static int countByCompanyId(long companyId) {
595                    return getPersistence().countByCompanyId(companyId);
596            }
597    
598            /**
599            * Returns all the document library file versions where fileEntryId = &#63;.
600            *
601            * @param fileEntryId the file entry ID
602            * @return the matching document library file versions
603            */
604            public static List<DLFileVersion> findByFileEntryId(long fileEntryId) {
605                    return getPersistence().findByFileEntryId(fileEntryId);
606            }
607    
608            /**
609            * Returns a range of all the document library file versions where fileEntryId = &#63;.
610            *
611            * <p>
612            * 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 DLFileVersionModelImpl}. 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.
613            * </p>
614            *
615            * @param fileEntryId the file entry ID
616            * @param start the lower bound of the range of document library file versions
617            * @param end the upper bound of the range of document library file versions (not inclusive)
618            * @return the range of matching document library file versions
619            */
620            public static List<DLFileVersion> findByFileEntryId(long fileEntryId,
621                    int start, int end) {
622                    return getPersistence().findByFileEntryId(fileEntryId, start, end);
623            }
624    
625            /**
626            * Returns an ordered range of all the document library file versions where fileEntryId = &#63;.
627            *
628            * <p>
629            * 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 DLFileVersionModelImpl}. 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.
630            * </p>
631            *
632            * @param fileEntryId the file entry ID
633            * @param start the lower bound of the range of document library file versions
634            * @param end the upper bound of the range of document library file versions (not inclusive)
635            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
636            * @return the ordered range of matching document library file versions
637            */
638            public static List<DLFileVersion> findByFileEntryId(long fileEntryId,
639                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
640                    return getPersistence()
641                                       .findByFileEntryId(fileEntryId, start, end, orderByComparator);
642            }
643    
644            /**
645            * Returns the first document library file version in the ordered set where fileEntryId = &#63;.
646            *
647            * @param fileEntryId the file entry ID
648            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
649            * @return the first matching document library file version
650            * @throws NoSuchFileVersionException if a matching document library file version could not be found
651            */
652            public static DLFileVersion findByFileEntryId_First(long fileEntryId,
653                    OrderByComparator<DLFileVersion> orderByComparator)
654                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
655                    return getPersistence()
656                                       .findByFileEntryId_First(fileEntryId, orderByComparator);
657            }
658    
659            /**
660            * Returns the first document library file version in the ordered set where fileEntryId = &#63;.
661            *
662            * @param fileEntryId the file entry ID
663            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
664            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
665            */
666            public static DLFileVersion fetchByFileEntryId_First(long fileEntryId,
667                    OrderByComparator<DLFileVersion> orderByComparator) {
668                    return getPersistence()
669                                       .fetchByFileEntryId_First(fileEntryId, orderByComparator);
670            }
671    
672            /**
673            * Returns the last document library file version in the ordered set where fileEntryId = &#63;.
674            *
675            * @param fileEntryId the file entry ID
676            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
677            * @return the last matching document library file version
678            * @throws NoSuchFileVersionException if a matching document library file version could not be found
679            */
680            public static DLFileVersion findByFileEntryId_Last(long fileEntryId,
681                    OrderByComparator<DLFileVersion> orderByComparator)
682                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
683                    return getPersistence()
684                                       .findByFileEntryId_Last(fileEntryId, orderByComparator);
685            }
686    
687            /**
688            * Returns the last document library file version in the ordered set where fileEntryId = &#63;.
689            *
690            * @param fileEntryId the file entry ID
691            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
692            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
693            */
694            public static DLFileVersion fetchByFileEntryId_Last(long fileEntryId,
695                    OrderByComparator<DLFileVersion> orderByComparator) {
696                    return getPersistence()
697                                       .fetchByFileEntryId_Last(fileEntryId, orderByComparator);
698            }
699    
700            /**
701            * Returns the document library file versions before and after the current document library file version in the ordered set where fileEntryId = &#63;.
702            *
703            * @param fileVersionId the primary key of the current document library file version
704            * @param fileEntryId the file entry ID
705            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
706            * @return the previous, current, and next document library file version
707            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
708            */
709            public static DLFileVersion[] findByFileEntryId_PrevAndNext(
710                    long fileVersionId, long fileEntryId,
711                    OrderByComparator<DLFileVersion> orderByComparator)
712                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
713                    return getPersistence()
714                                       .findByFileEntryId_PrevAndNext(fileVersionId, fileEntryId,
715                            orderByComparator);
716            }
717    
718            /**
719            * Removes all the document library file versions where fileEntryId = &#63; from the database.
720            *
721            * @param fileEntryId the file entry ID
722            */
723            public static void removeByFileEntryId(long fileEntryId) {
724                    getPersistence().removeByFileEntryId(fileEntryId);
725            }
726    
727            /**
728            * Returns the number of document library file versions where fileEntryId = &#63;.
729            *
730            * @param fileEntryId the file entry ID
731            * @return the number of matching document library file versions
732            */
733            public static int countByFileEntryId(long fileEntryId) {
734                    return getPersistence().countByFileEntryId(fileEntryId);
735            }
736    
737            /**
738            * Returns all the document library file versions where mimeType = &#63;.
739            *
740            * @param mimeType the mime type
741            * @return the matching document library file versions
742            */
743            public static List<DLFileVersion> findByMimeType(java.lang.String mimeType) {
744                    return getPersistence().findByMimeType(mimeType);
745            }
746    
747            /**
748            * Returns a range of all the document library file versions where mimeType = &#63;.
749            *
750            * <p>
751            * 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 DLFileVersionModelImpl}. 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.
752            * </p>
753            *
754            * @param mimeType the mime type
755            * @param start the lower bound of the range of document library file versions
756            * @param end the upper bound of the range of document library file versions (not inclusive)
757            * @return the range of matching document library file versions
758            */
759            public static List<DLFileVersion> findByMimeType(
760                    java.lang.String mimeType, int start, int end) {
761                    return getPersistence().findByMimeType(mimeType, start, end);
762            }
763    
764            /**
765            * Returns an ordered range of all the document library file versions where mimeType = &#63;.
766            *
767            * <p>
768            * 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 DLFileVersionModelImpl}. 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.
769            * </p>
770            *
771            * @param mimeType the mime type
772            * @param start the lower bound of the range of document library file versions
773            * @param end the upper bound of the range of document library file versions (not inclusive)
774            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
775            * @return the ordered range of matching document library file versions
776            */
777            public static List<DLFileVersion> findByMimeType(
778                    java.lang.String mimeType, int start, int end,
779                    OrderByComparator<DLFileVersion> orderByComparator) {
780                    return getPersistence()
781                                       .findByMimeType(mimeType, start, end, orderByComparator);
782            }
783    
784            /**
785            * Returns the first document library file version in the ordered set where mimeType = &#63;.
786            *
787            * @param mimeType the mime type
788            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
789            * @return the first matching document library file version
790            * @throws NoSuchFileVersionException if a matching document library file version could not be found
791            */
792            public static DLFileVersion findByMimeType_First(
793                    java.lang.String mimeType,
794                    OrderByComparator<DLFileVersion> orderByComparator)
795                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
796                    return getPersistence().findByMimeType_First(mimeType, orderByComparator);
797            }
798    
799            /**
800            * Returns the first document library file version in the ordered set where mimeType = &#63;.
801            *
802            * @param mimeType the mime type
803            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
804            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
805            */
806            public static DLFileVersion fetchByMimeType_First(
807                    java.lang.String mimeType,
808                    OrderByComparator<DLFileVersion> orderByComparator) {
809                    return getPersistence()
810                                       .fetchByMimeType_First(mimeType, orderByComparator);
811            }
812    
813            /**
814            * Returns the last document library file version in the ordered set where mimeType = &#63;.
815            *
816            * @param mimeType the mime type
817            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
818            * @return the last matching document library file version
819            * @throws NoSuchFileVersionException if a matching document library file version could not be found
820            */
821            public static DLFileVersion findByMimeType_Last(java.lang.String mimeType,
822                    OrderByComparator<DLFileVersion> orderByComparator)
823                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
824                    return getPersistence().findByMimeType_Last(mimeType, orderByComparator);
825            }
826    
827            /**
828            * Returns the last document library file version in the ordered set where mimeType = &#63;.
829            *
830            * @param mimeType the mime type
831            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
832            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
833            */
834            public static DLFileVersion fetchByMimeType_Last(
835                    java.lang.String mimeType,
836                    OrderByComparator<DLFileVersion> orderByComparator) {
837                    return getPersistence().fetchByMimeType_Last(mimeType, orderByComparator);
838            }
839    
840            /**
841            * Returns the document library file versions before and after the current document library file version in the ordered set where mimeType = &#63;.
842            *
843            * @param fileVersionId the primary key of the current document library file version
844            * @param mimeType the mime type
845            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
846            * @return the previous, current, and next document library file version
847            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
848            */
849            public static DLFileVersion[] findByMimeType_PrevAndNext(
850                    long fileVersionId, java.lang.String mimeType,
851                    OrderByComparator<DLFileVersion> orderByComparator)
852                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
853                    return getPersistence()
854                                       .findByMimeType_PrevAndNext(fileVersionId, mimeType,
855                            orderByComparator);
856            }
857    
858            /**
859            * Removes all the document library file versions where mimeType = &#63; from the database.
860            *
861            * @param mimeType the mime type
862            */
863            public static void removeByMimeType(java.lang.String mimeType) {
864                    getPersistence().removeByMimeType(mimeType);
865            }
866    
867            /**
868            * Returns the number of document library file versions where mimeType = &#63;.
869            *
870            * @param mimeType the mime type
871            * @return the number of matching document library file versions
872            */
873            public static int countByMimeType(java.lang.String mimeType) {
874                    return getPersistence().countByMimeType(mimeType);
875            }
876    
877            /**
878            * Returns all the document library file versions where companyId = &#63; and status &ne; &#63;.
879            *
880            * @param companyId the company ID
881            * @param status the status
882            * @return the matching document library file versions
883            */
884            public static List<DLFileVersion> findByC_NotS(long companyId, int status) {
885                    return getPersistence().findByC_NotS(companyId, status);
886            }
887    
888            /**
889            * Returns a range of all the document library file versions where companyId = &#63; and status &ne; &#63;.
890            *
891            * <p>
892            * 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 DLFileVersionModelImpl}. 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.
893            * </p>
894            *
895            * @param companyId the company ID
896            * @param status the status
897            * @param start the lower bound of the range of document library file versions
898            * @param end the upper bound of the range of document library file versions (not inclusive)
899            * @return the range of matching document library file versions
900            */
901            public static List<DLFileVersion> findByC_NotS(long companyId, int status,
902                    int start, int end) {
903                    return getPersistence().findByC_NotS(companyId, status, start, end);
904            }
905    
906            /**
907            * Returns an ordered range of all the document library file versions where companyId = &#63; and status &ne; &#63;.
908            *
909            * <p>
910            * 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 DLFileVersionModelImpl}. 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.
911            * </p>
912            *
913            * @param companyId the company ID
914            * @param status the status
915            * @param start the lower bound of the range of document library file versions
916            * @param end the upper bound of the range of document library file versions (not inclusive)
917            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
918            * @return the ordered range of matching document library file versions
919            */
920            public static List<DLFileVersion> findByC_NotS(long companyId, int status,
921                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
922                    return getPersistence()
923                                       .findByC_NotS(companyId, status, start, end,
924                            orderByComparator);
925            }
926    
927            /**
928            * Returns the first document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
929            *
930            * @param companyId the company ID
931            * @param status the status
932            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
933            * @return the first matching document library file version
934            * @throws NoSuchFileVersionException if a matching document library file version could not be found
935            */
936            public static DLFileVersion findByC_NotS_First(long companyId, int status,
937                    OrderByComparator<DLFileVersion> orderByComparator)
938                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
939                    return getPersistence()
940                                       .findByC_NotS_First(companyId, status, orderByComparator);
941            }
942    
943            /**
944            * Returns the first document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
945            *
946            * @param companyId the company ID
947            * @param status the status
948            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
949            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
950            */
951            public static DLFileVersion fetchByC_NotS_First(long companyId, int status,
952                    OrderByComparator<DLFileVersion> orderByComparator) {
953                    return getPersistence()
954                                       .fetchByC_NotS_First(companyId, status, orderByComparator);
955            }
956    
957            /**
958            * Returns the last document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
959            *
960            * @param companyId the company ID
961            * @param status the status
962            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
963            * @return the last matching document library file version
964            * @throws NoSuchFileVersionException if a matching document library file version could not be found
965            */
966            public static DLFileVersion findByC_NotS_Last(long companyId, int status,
967                    OrderByComparator<DLFileVersion> orderByComparator)
968                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
969                    return getPersistence()
970                                       .findByC_NotS_Last(companyId, status, orderByComparator);
971            }
972    
973            /**
974            * Returns the last document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
975            *
976            * @param companyId the company ID
977            * @param status the status
978            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
979            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
980            */
981            public static DLFileVersion fetchByC_NotS_Last(long companyId, int status,
982                    OrderByComparator<DLFileVersion> orderByComparator) {
983                    return getPersistence()
984                                       .fetchByC_NotS_Last(companyId, status, orderByComparator);
985            }
986    
987            /**
988            * Returns the document library file versions before and after the current document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
989            *
990            * @param fileVersionId the primary key of the current document library file version
991            * @param companyId the company ID
992            * @param status the status
993            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
994            * @return the previous, current, and next document library file version
995            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
996            */
997            public static DLFileVersion[] findByC_NotS_PrevAndNext(long fileVersionId,
998                    long companyId, int status,
999                    OrderByComparator<DLFileVersion> orderByComparator)
1000                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1001                    return getPersistence()
1002                                       .findByC_NotS_PrevAndNext(fileVersionId, companyId, status,
1003                            orderByComparator);
1004            }
1005    
1006            /**
1007            * Removes all the document library file versions where companyId = &#63; and status &ne; &#63; from the database.
1008            *
1009            * @param companyId the company ID
1010            * @param status the status
1011            */
1012            public static void removeByC_NotS(long companyId, int status) {
1013                    getPersistence().removeByC_NotS(companyId, status);
1014            }
1015    
1016            /**
1017            * Returns the number of document library file versions where companyId = &#63; and status &ne; &#63;.
1018            *
1019            * @param companyId the company ID
1020            * @param status the status
1021            * @return the number of matching document library file versions
1022            */
1023            public static int countByC_NotS(long companyId, int status) {
1024                    return getPersistence().countByC_NotS(companyId, status);
1025            }
1026    
1027            /**
1028            * Returns the document library file version where fileEntryId = &#63; and version = &#63; or throws a {@link NoSuchFileVersionException} if it could not be found.
1029            *
1030            * @param fileEntryId the file entry ID
1031            * @param version the version
1032            * @return the matching document library file version
1033            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1034            */
1035            public static DLFileVersion findByF_V(long fileEntryId,
1036                    java.lang.String version)
1037                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1038                    return getPersistence().findByF_V(fileEntryId, version);
1039            }
1040    
1041            /**
1042            * Returns the document library file version where fileEntryId = &#63; and version = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1043            *
1044            * @param fileEntryId the file entry ID
1045            * @param version the version
1046            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
1047            */
1048            public static DLFileVersion fetchByF_V(long fileEntryId,
1049                    java.lang.String version) {
1050                    return getPersistence().fetchByF_V(fileEntryId, version);
1051            }
1052    
1053            /**
1054            * Returns the document library file version where fileEntryId = &#63; and version = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1055            *
1056            * @param fileEntryId the file entry ID
1057            * @param version the version
1058            * @param retrieveFromCache whether to use the finder cache
1059            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
1060            */
1061            public static DLFileVersion fetchByF_V(long fileEntryId,
1062                    java.lang.String version, boolean retrieveFromCache) {
1063                    return getPersistence()
1064                                       .fetchByF_V(fileEntryId, version, retrieveFromCache);
1065            }
1066    
1067            /**
1068            * Removes the document library file version where fileEntryId = &#63; and version = &#63; from the database.
1069            *
1070            * @param fileEntryId the file entry ID
1071            * @param version the version
1072            * @return the document library file version that was removed
1073            */
1074            public static DLFileVersion removeByF_V(long fileEntryId,
1075                    java.lang.String version)
1076                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1077                    return getPersistence().removeByF_V(fileEntryId, version);
1078            }
1079    
1080            /**
1081            * Returns the number of document library file versions where fileEntryId = &#63; and version = &#63;.
1082            *
1083            * @param fileEntryId the file entry ID
1084            * @param version the version
1085            * @return the number of matching document library file versions
1086            */
1087            public static int countByF_V(long fileEntryId, java.lang.String version) {
1088                    return getPersistence().countByF_V(fileEntryId, version);
1089            }
1090    
1091            /**
1092            * Returns all the document library file versions where fileEntryId = &#63; and status = &#63;.
1093            *
1094            * @param fileEntryId the file entry ID
1095            * @param status the status
1096            * @return the matching document library file versions
1097            */
1098            public static List<DLFileVersion> findByF_S(long fileEntryId, int status) {
1099                    return getPersistence().findByF_S(fileEntryId, status);
1100            }
1101    
1102            /**
1103            * Returns a range of all the document library file versions where fileEntryId = &#63; and status = &#63;.
1104            *
1105            * <p>
1106            * 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 DLFileVersionModelImpl}. 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.
1107            * </p>
1108            *
1109            * @param fileEntryId the file entry ID
1110            * @param status the status
1111            * @param start the lower bound of the range of document library file versions
1112            * @param end the upper bound of the range of document library file versions (not inclusive)
1113            * @return the range of matching document library file versions
1114            */
1115            public static List<DLFileVersion> findByF_S(long fileEntryId, int status,
1116                    int start, int end) {
1117                    return getPersistence().findByF_S(fileEntryId, status, start, end);
1118            }
1119    
1120            /**
1121            * Returns an ordered range of all the document library file versions where fileEntryId = &#63; and status = &#63;.
1122            *
1123            * <p>
1124            * 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 DLFileVersionModelImpl}. 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.
1125            * </p>
1126            *
1127            * @param fileEntryId the file entry ID
1128            * @param status the status
1129            * @param start the lower bound of the range of document library file versions
1130            * @param end the upper bound of the range of document library file versions (not inclusive)
1131            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1132            * @return the ordered range of matching document library file versions
1133            */
1134            public static List<DLFileVersion> findByF_S(long fileEntryId, int status,
1135                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
1136                    return getPersistence()
1137                                       .findByF_S(fileEntryId, status, start, end, orderByComparator);
1138            }
1139    
1140            /**
1141            * Returns the first document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1142            *
1143            * @param fileEntryId the file entry ID
1144            * @param status the status
1145            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1146            * @return the first matching document library file version
1147            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1148            */
1149            public static DLFileVersion findByF_S_First(long fileEntryId, int status,
1150                    OrderByComparator<DLFileVersion> orderByComparator)
1151                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1152                    return getPersistence()
1153                                       .findByF_S_First(fileEntryId, status, orderByComparator);
1154            }
1155    
1156            /**
1157            * Returns the first document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1158            *
1159            * @param fileEntryId the file entry ID
1160            * @param status the status
1161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1162            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
1163            */
1164            public static DLFileVersion fetchByF_S_First(long fileEntryId, int status,
1165                    OrderByComparator<DLFileVersion> orderByComparator) {
1166                    return getPersistence()
1167                                       .fetchByF_S_First(fileEntryId, status, orderByComparator);
1168            }
1169    
1170            /**
1171            * Returns the last document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1172            *
1173            * @param fileEntryId the file entry ID
1174            * @param status the status
1175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1176            * @return the last matching document library file version
1177            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1178            */
1179            public static DLFileVersion findByF_S_Last(long fileEntryId, int status,
1180                    OrderByComparator<DLFileVersion> orderByComparator)
1181                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1182                    return getPersistence()
1183                                       .findByF_S_Last(fileEntryId, status, orderByComparator);
1184            }
1185    
1186            /**
1187            * Returns the last document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1188            *
1189            * @param fileEntryId the file entry ID
1190            * @param status the status
1191            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1192            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
1193            */
1194            public static DLFileVersion fetchByF_S_Last(long fileEntryId, int status,
1195                    OrderByComparator<DLFileVersion> orderByComparator) {
1196                    return getPersistence()
1197                                       .fetchByF_S_Last(fileEntryId, status, orderByComparator);
1198            }
1199    
1200            /**
1201            * Returns the document library file versions before and after the current document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1202            *
1203            * @param fileVersionId the primary key of the current document library file version
1204            * @param fileEntryId the file entry ID
1205            * @param status the status
1206            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1207            * @return the previous, current, and next document library file version
1208            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1209            */
1210            public static DLFileVersion[] findByF_S_PrevAndNext(long fileVersionId,
1211                    long fileEntryId, int status,
1212                    OrderByComparator<DLFileVersion> orderByComparator)
1213                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1214                    return getPersistence()
1215                                       .findByF_S_PrevAndNext(fileVersionId, fileEntryId, status,
1216                            orderByComparator);
1217            }
1218    
1219            /**
1220            * Removes all the document library file versions where fileEntryId = &#63; and status = &#63; from the database.
1221            *
1222            * @param fileEntryId the file entry ID
1223            * @param status the status
1224            */
1225            public static void removeByF_S(long fileEntryId, int status) {
1226                    getPersistence().removeByF_S(fileEntryId, status);
1227            }
1228    
1229            /**
1230            * Returns the number of document library file versions where fileEntryId = &#63; and status = &#63;.
1231            *
1232            * @param fileEntryId the file entry ID
1233            * @param status the status
1234            * @return the number of matching document library file versions
1235            */
1236            public static int countByF_S(long fileEntryId, int status) {
1237                    return getPersistence().countByF_S(fileEntryId, status);
1238            }
1239    
1240            /**
1241            * Returns all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1242            *
1243            * @param groupId the group ID
1244            * @param folderId the folder ID
1245            * @param status the status
1246            * @return the matching document library file versions
1247            */
1248            public static List<DLFileVersion> findByG_F_S(long groupId, long folderId,
1249                    int status) {
1250                    return getPersistence().findByG_F_S(groupId, folderId, status);
1251            }
1252    
1253            /**
1254            * Returns a range of all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1255            *
1256            * <p>
1257            * 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 DLFileVersionModelImpl}. 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.
1258            * </p>
1259            *
1260            * @param groupId the group ID
1261            * @param folderId the folder ID
1262            * @param status the status
1263            * @param start the lower bound of the range of document library file versions
1264            * @param end the upper bound of the range of document library file versions (not inclusive)
1265            * @return the range of matching document library file versions
1266            */
1267            public static List<DLFileVersion> findByG_F_S(long groupId, long folderId,
1268                    int status, int start, int end) {
1269                    return getPersistence()
1270                                       .findByG_F_S(groupId, folderId, status, start, end);
1271            }
1272    
1273            /**
1274            * Returns an ordered range of all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1275            *
1276            * <p>
1277            * 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 DLFileVersionModelImpl}. 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.
1278            * </p>
1279            *
1280            * @param groupId the group ID
1281            * @param folderId the folder ID
1282            * @param status the status
1283            * @param start the lower bound of the range of document library file versions
1284            * @param end the upper bound of the range of document library file versions (not inclusive)
1285            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1286            * @return the ordered range of matching document library file versions
1287            */
1288            public static List<DLFileVersion> findByG_F_S(long groupId, long folderId,
1289                    int status, int start, int end,
1290                    OrderByComparator<DLFileVersion> orderByComparator) {
1291                    return getPersistence()
1292                                       .findByG_F_S(groupId, folderId, status, start, end,
1293                            orderByComparator);
1294            }
1295    
1296            /**
1297            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1298            *
1299            * @param groupId the group ID
1300            * @param folderId the folder ID
1301            * @param status the status
1302            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1303            * @return the first matching document library file version
1304            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1305            */
1306            public static DLFileVersion findByG_F_S_First(long groupId, long folderId,
1307                    int status, OrderByComparator<DLFileVersion> orderByComparator)
1308                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1309                    return getPersistence()
1310                                       .findByG_F_S_First(groupId, folderId, status,
1311                            orderByComparator);
1312            }
1313    
1314            /**
1315            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1316            *
1317            * @param groupId the group ID
1318            * @param folderId the folder ID
1319            * @param status the status
1320            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1321            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
1322            */
1323            public static DLFileVersion fetchByG_F_S_First(long groupId, long folderId,
1324                    int status, OrderByComparator<DLFileVersion> orderByComparator) {
1325                    return getPersistence()
1326                                       .fetchByG_F_S_First(groupId, folderId, status,
1327                            orderByComparator);
1328            }
1329    
1330            /**
1331            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1332            *
1333            * @param groupId the group ID
1334            * @param folderId the folder ID
1335            * @param status the status
1336            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1337            * @return the last matching document library file version
1338            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1339            */
1340            public static DLFileVersion findByG_F_S_Last(long groupId, long folderId,
1341                    int status, OrderByComparator<DLFileVersion> orderByComparator)
1342                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1343                    return getPersistence()
1344                                       .findByG_F_S_Last(groupId, folderId, status,
1345                            orderByComparator);
1346            }
1347    
1348            /**
1349            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1350            *
1351            * @param groupId the group ID
1352            * @param folderId the folder ID
1353            * @param status the status
1354            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1355            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
1356            */
1357            public static DLFileVersion fetchByG_F_S_Last(long groupId, long folderId,
1358                    int status, OrderByComparator<DLFileVersion> orderByComparator) {
1359                    return getPersistence()
1360                                       .fetchByG_F_S_Last(groupId, folderId, status,
1361                            orderByComparator);
1362            }
1363    
1364            /**
1365            * Returns the document library file versions before and after the current document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1366            *
1367            * @param fileVersionId the primary key of the current document library file version
1368            * @param groupId the group ID
1369            * @param folderId the folder ID
1370            * @param status the status
1371            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1372            * @return the previous, current, and next document library file version
1373            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1374            */
1375            public static DLFileVersion[] findByG_F_S_PrevAndNext(long fileVersionId,
1376                    long groupId, long folderId, int status,
1377                    OrderByComparator<DLFileVersion> orderByComparator)
1378                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1379                    return getPersistence()
1380                                       .findByG_F_S_PrevAndNext(fileVersionId, groupId, folderId,
1381                            status, orderByComparator);
1382            }
1383    
1384            /**
1385            * Removes all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
1386            *
1387            * @param groupId the group ID
1388            * @param folderId the folder ID
1389            * @param status the status
1390            */
1391            public static void removeByG_F_S(long groupId, long folderId, int status) {
1392                    getPersistence().removeByG_F_S(groupId, folderId, status);
1393            }
1394    
1395            /**
1396            * Returns the number of document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1397            *
1398            * @param groupId the group ID
1399            * @param folderId the folder ID
1400            * @param status the status
1401            * @return the number of matching document library file versions
1402            */
1403            public static int countByG_F_S(long groupId, long folderId, int status) {
1404                    return getPersistence().countByG_F_S(groupId, folderId, status);
1405            }
1406    
1407            /**
1408            * Returns all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1409            *
1410            * @param groupId the group ID
1411            * @param folderId the folder ID
1412            * @param title the title
1413            * @param version the version
1414            * @return the matching document library file versions
1415            */
1416            public static List<DLFileVersion> findByG_F_T_V(long groupId,
1417                    long folderId, java.lang.String title, java.lang.String version) {
1418                    return getPersistence().findByG_F_T_V(groupId, folderId, title, version);
1419            }
1420    
1421            /**
1422            * Returns a range of all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1423            *
1424            * <p>
1425            * 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 DLFileVersionModelImpl}. 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.
1426            * </p>
1427            *
1428            * @param groupId the group ID
1429            * @param folderId the folder ID
1430            * @param title the title
1431            * @param version the version
1432            * @param start the lower bound of the range of document library file versions
1433            * @param end the upper bound of the range of document library file versions (not inclusive)
1434            * @return the range of matching document library file versions
1435            */
1436            public static List<DLFileVersion> findByG_F_T_V(long groupId,
1437                    long folderId, java.lang.String title, java.lang.String version,
1438                    int start, int end) {
1439                    return getPersistence()
1440                                       .findByG_F_T_V(groupId, folderId, title, version, start, end);
1441            }
1442    
1443            /**
1444            * Returns an ordered range of all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1445            *
1446            * <p>
1447            * 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 DLFileVersionModelImpl}. 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.
1448            * </p>
1449            *
1450            * @param groupId the group ID
1451            * @param folderId the folder ID
1452            * @param title the title
1453            * @param version the version
1454            * @param start the lower bound of the range of document library file versions
1455            * @param end the upper bound of the range of document library file versions (not inclusive)
1456            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1457            * @return the ordered range of matching document library file versions
1458            */
1459            public static List<DLFileVersion> findByG_F_T_V(long groupId,
1460                    long folderId, java.lang.String title, java.lang.String version,
1461                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
1462                    return getPersistence()
1463                                       .findByG_F_T_V(groupId, folderId, title, version, start,
1464                            end, orderByComparator);
1465            }
1466    
1467            /**
1468            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1469            *
1470            * @param groupId the group ID
1471            * @param folderId the folder ID
1472            * @param title the title
1473            * @param version the version
1474            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1475            * @return the first matching document library file version
1476            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1477            */
1478            public static DLFileVersion findByG_F_T_V_First(long groupId,
1479                    long folderId, java.lang.String title, java.lang.String version,
1480                    OrderByComparator<DLFileVersion> orderByComparator)
1481                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1482                    return getPersistence()
1483                                       .findByG_F_T_V_First(groupId, folderId, title, version,
1484                            orderByComparator);
1485            }
1486    
1487            /**
1488            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1489            *
1490            * @param groupId the group ID
1491            * @param folderId the folder ID
1492            * @param title the title
1493            * @param version the version
1494            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1495            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
1496            */
1497            public static DLFileVersion fetchByG_F_T_V_First(long groupId,
1498                    long folderId, java.lang.String title, java.lang.String version,
1499                    OrderByComparator<DLFileVersion> orderByComparator) {
1500                    return getPersistence()
1501                                       .fetchByG_F_T_V_First(groupId, folderId, title, version,
1502                            orderByComparator);
1503            }
1504    
1505            /**
1506            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1507            *
1508            * @param groupId the group ID
1509            * @param folderId the folder ID
1510            * @param title the title
1511            * @param version the version
1512            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1513            * @return the last matching document library file version
1514            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1515            */
1516            public static DLFileVersion findByG_F_T_V_Last(long groupId, long folderId,
1517                    java.lang.String title, java.lang.String version,
1518                    OrderByComparator<DLFileVersion> orderByComparator)
1519                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1520                    return getPersistence()
1521                                       .findByG_F_T_V_Last(groupId, folderId, title, version,
1522                            orderByComparator);
1523            }
1524    
1525            /**
1526            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1527            *
1528            * @param groupId the group ID
1529            * @param folderId the folder ID
1530            * @param title the title
1531            * @param version the version
1532            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1533            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
1534            */
1535            public static DLFileVersion fetchByG_F_T_V_Last(long groupId,
1536                    long folderId, java.lang.String title, java.lang.String version,
1537                    OrderByComparator<DLFileVersion> orderByComparator) {
1538                    return getPersistence()
1539                                       .fetchByG_F_T_V_Last(groupId, folderId, title, version,
1540                            orderByComparator);
1541            }
1542    
1543            /**
1544            * Returns the document library file versions before and after the current document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1545            *
1546            * @param fileVersionId the primary key of the current document library file version
1547            * @param groupId the group ID
1548            * @param folderId the folder ID
1549            * @param title the title
1550            * @param version the version
1551            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1552            * @return the previous, current, and next document library file version
1553            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1554            */
1555            public static DLFileVersion[] findByG_F_T_V_PrevAndNext(
1556                    long fileVersionId, long groupId, long folderId,
1557                    java.lang.String title, java.lang.String version,
1558                    OrderByComparator<DLFileVersion> orderByComparator)
1559                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1560                    return getPersistence()
1561                                       .findByG_F_T_V_PrevAndNext(fileVersionId, groupId, folderId,
1562                            title, version, orderByComparator);
1563            }
1564    
1565            /**
1566            * Removes all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63; from the database.
1567            *
1568            * @param groupId the group ID
1569            * @param folderId the folder ID
1570            * @param title the title
1571            * @param version the version
1572            */
1573            public static void removeByG_F_T_V(long groupId, long folderId,
1574                    java.lang.String title, java.lang.String version) {
1575                    getPersistence().removeByG_F_T_V(groupId, folderId, title, version);
1576            }
1577    
1578            /**
1579            * Returns the number of document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1580            *
1581            * @param groupId the group ID
1582            * @param folderId the folder ID
1583            * @param title the title
1584            * @param version the version
1585            * @return the number of matching document library file versions
1586            */
1587            public static int countByG_F_T_V(long groupId, long folderId,
1588                    java.lang.String title, java.lang.String version) {
1589                    return getPersistence().countByG_F_T_V(groupId, folderId, title, version);
1590            }
1591    
1592            /**
1593            * Caches the document library file version in the entity cache if it is enabled.
1594            *
1595            * @param dlFileVersion the document library file version
1596            */
1597            public static void cacheResult(DLFileVersion dlFileVersion) {
1598                    getPersistence().cacheResult(dlFileVersion);
1599            }
1600    
1601            /**
1602            * Caches the document library file versions in the entity cache if it is enabled.
1603            *
1604            * @param dlFileVersions the document library file versions
1605            */
1606            public static void cacheResult(List<DLFileVersion> dlFileVersions) {
1607                    getPersistence().cacheResult(dlFileVersions);
1608            }
1609    
1610            /**
1611            * Creates a new document library file version with the primary key. Does not add the document library file version to the database.
1612            *
1613            * @param fileVersionId the primary key for the new document library file version
1614            * @return the new document library file version
1615            */
1616            public static DLFileVersion create(long fileVersionId) {
1617                    return getPersistence().create(fileVersionId);
1618            }
1619    
1620            /**
1621            * Removes the document library file version with the primary key from the database. Also notifies the appropriate model listeners.
1622            *
1623            * @param fileVersionId the primary key of the document library file version
1624            * @return the document library file version that was removed
1625            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1626            */
1627            public static DLFileVersion remove(long fileVersionId)
1628                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1629                    return getPersistence().remove(fileVersionId);
1630            }
1631    
1632            public static DLFileVersion updateImpl(DLFileVersion dlFileVersion) {
1633                    return getPersistence().updateImpl(dlFileVersion);
1634            }
1635    
1636            /**
1637            * Returns the document library file version with the primary key or throws a {@link NoSuchFileVersionException} if it could not be found.
1638            *
1639            * @param fileVersionId the primary key of the document library file version
1640            * @return the document library file version
1641            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1642            */
1643            public static DLFileVersion findByPrimaryKey(long fileVersionId)
1644                    throws com.liferay.portlet.documentlibrary.NoSuchFileVersionException {
1645                    return getPersistence().findByPrimaryKey(fileVersionId);
1646            }
1647    
1648            /**
1649            * Returns the document library file version with the primary key or returns <code>null</code> if it could not be found.
1650            *
1651            * @param fileVersionId the primary key of the document library file version
1652            * @return the document library file version, or <code>null</code> if a document library file version with the primary key could not be found
1653            */
1654            public static DLFileVersion fetchByPrimaryKey(long fileVersionId) {
1655                    return getPersistence().fetchByPrimaryKey(fileVersionId);
1656            }
1657    
1658            public static java.util.Map<java.io.Serializable, DLFileVersion> fetchByPrimaryKeys(
1659                    java.util.Set<java.io.Serializable> primaryKeys) {
1660                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1661            }
1662    
1663            /**
1664            * Returns all the document library file versions.
1665            *
1666            * @return the document library file versions
1667            */
1668            public static List<DLFileVersion> findAll() {
1669                    return getPersistence().findAll();
1670            }
1671    
1672            /**
1673            * Returns a range of all the document library file versions.
1674            *
1675            * <p>
1676            * 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 DLFileVersionModelImpl}. 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.
1677            * </p>
1678            *
1679            * @param start the lower bound of the range of document library file versions
1680            * @param end the upper bound of the range of document library file versions (not inclusive)
1681            * @return the range of document library file versions
1682            */
1683            public static List<DLFileVersion> findAll(int start, int end) {
1684                    return getPersistence().findAll(start, end);
1685            }
1686    
1687            /**
1688            * Returns an ordered range of all the document library file versions.
1689            *
1690            * <p>
1691            * 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 DLFileVersionModelImpl}. 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.
1692            * </p>
1693            *
1694            * @param start the lower bound of the range of document library file versions
1695            * @param end the upper bound of the range of document library file versions (not inclusive)
1696            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1697            * @return the ordered range of document library file versions
1698            */
1699            public static List<DLFileVersion> findAll(int start, int end,
1700                    OrderByComparator<DLFileVersion> orderByComparator) {
1701                    return getPersistence().findAll(start, end, orderByComparator);
1702            }
1703    
1704            /**
1705            * Removes all the document library file versions from the database.
1706            */
1707            public static void removeAll() {
1708                    getPersistence().removeAll();
1709            }
1710    
1711            /**
1712            * Returns the number of document library file versions.
1713            *
1714            * @return the number of document library file versions
1715            */
1716            public static int countAll() {
1717                    return getPersistence().countAll();
1718            }
1719    
1720            public static DLFileVersionPersistence getPersistence() {
1721                    if (_persistence == null) {
1722                            _persistence = (DLFileVersionPersistence)PortalBeanLocatorUtil.locate(DLFileVersionPersistence.class.getName());
1723    
1724                            ReferenceRegistry.registerReference(DLFileVersionUtil.class,
1725                                    "_persistence");
1726                    }
1727    
1728                    return _persistence;
1729            }
1730    
1731            /**
1732             * @deprecated As of 6.2.0
1733             */
1734            @Deprecated
1735            public void setPersistence(DLFileVersionPersistence persistence) {
1736            }
1737    
1738            private static DLFileVersionPersistence _persistence;
1739    }