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