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.dynamicdatamapping.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.dynamicdatamapping.model.DDMStorageLink;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the d d m storage link service. This utility wraps {@link com.liferay.portlet.dynamicdatamapping.service.persistence.impl.DDMStorageLinkPersistenceImpl} 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 DDMStorageLinkPersistence
038     * @see com.liferay.portlet.dynamicdatamapping.service.persistence.impl.DDMStorageLinkPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class DDMStorageLinkUtil {
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(DDMStorageLink ddmStorageLink) {
060                    getPersistence().clearCache(ddmStorageLink);
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<DDMStorageLink> 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<DDMStorageLink> 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<DDMStorageLink> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<DDMStorageLink> 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 DDMStorageLink update(DDMStorageLink ddmStorageLink) {
101                    return getPersistence().update(ddmStorageLink);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static DDMStorageLink update(DDMStorageLink ddmStorageLink,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(ddmStorageLink, serviceContext);
110            }
111    
112            /**
113            * Returns all the d d m storage links where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching d d m storage links
117            */
118            public static List<DDMStorageLink> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the d d m storage links 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 DDMStorageLinkModelImpl}. 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 d d m storage links
131            * @param end the upper bound of the range of d d m storage links (not inclusive)
132            * @return the range of matching d d m storage links
133            */
134            public static List<DDMStorageLink> 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 d d m storage links 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 DDMStorageLinkModelImpl}. 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 d d m storage links
148            * @param end the upper bound of the range of d d m storage links (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching d d m storage links
151            */
152            public static List<DDMStorageLink> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<DDMStorageLink> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first d d m storage link in the ordered set where uuid = &#63;.
159            *
160            * @param uuid the uuid
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching d d m storage link
163            * @throws NoSuchStorageLinkException if a matching d d m storage link could not be found
164            */
165            public static DDMStorageLink findByUuid_First(java.lang.String uuid,
166                    OrderByComparator<DDMStorageLink> orderByComparator)
167                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStorageLinkException {
168                    return getPersistence().findByUuid_First(uuid, orderByComparator);
169            }
170    
171            /**
172            * Returns the first d d m storage link in the ordered set where uuid = &#63;.
173            *
174            * @param uuid the uuid
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching d d m storage link, or <code>null</code> if a matching d d m storage link could not be found
177            */
178            public static DDMStorageLink fetchByUuid_First(java.lang.String uuid,
179                    OrderByComparator<DDMStorageLink> orderByComparator) {
180                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the last d d m storage link in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the last matching d d m storage link
189            * @throws NoSuchStorageLinkException if a matching d d m storage link could not be found
190            */
191            public static DDMStorageLink findByUuid_Last(java.lang.String uuid,
192                    OrderByComparator<DDMStorageLink> orderByComparator)
193                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStorageLinkException {
194                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last d d m storage link in the ordered set where uuid = &#63;.
199            *
200            * @param uuid the uuid
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching d d m storage link, or <code>null</code> if a matching d d m storage link could not be found
203            */
204            public static DDMStorageLink fetchByUuid_Last(java.lang.String uuid,
205                    OrderByComparator<DDMStorageLink> orderByComparator) {
206                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
207            }
208    
209            /**
210            * Returns the d d m storage links before and after the current d d m storage link in the ordered set where uuid = &#63;.
211            *
212            * @param storageLinkId the primary key of the current d d m storage link
213            * @param uuid the uuid
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the previous, current, and next d d m storage link
216            * @throws NoSuchStorageLinkException if a d d m storage link with the primary key could not be found
217            */
218            public static DDMStorageLink[] findByUuid_PrevAndNext(long storageLinkId,
219                    java.lang.String uuid,
220                    OrderByComparator<DDMStorageLink> orderByComparator)
221                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStorageLinkException {
222                    return getPersistence()
223                                       .findByUuid_PrevAndNext(storageLinkId, uuid,
224                            orderByComparator);
225            }
226    
227            /**
228            * Removes all the d d m storage links where uuid = &#63; from the database.
229            *
230            * @param uuid the uuid
231            */
232            public static void removeByUuid(java.lang.String uuid) {
233                    getPersistence().removeByUuid(uuid);
234            }
235    
236            /**
237            * Returns the number of d d m storage links where uuid = &#63;.
238            *
239            * @param uuid the uuid
240            * @return the number of matching d d m storage links
241            */
242            public static int countByUuid(java.lang.String uuid) {
243                    return getPersistence().countByUuid(uuid);
244            }
245    
246            /**
247            * Returns the d d m storage link where classPK = &#63; or throws a {@link NoSuchStorageLinkException} if it could not be found.
248            *
249            * @param classPK the class p k
250            * @return the matching d d m storage link
251            * @throws NoSuchStorageLinkException if a matching d d m storage link could not be found
252            */
253            public static DDMStorageLink findByClassPK(long classPK)
254                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStorageLinkException {
255                    return getPersistence().findByClassPK(classPK);
256            }
257    
258            /**
259            * Returns the d d m storage link where classPK = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
260            *
261            * @param classPK the class p k
262            * @return the matching d d m storage link, or <code>null</code> if a matching d d m storage link could not be found
263            */
264            public static DDMStorageLink fetchByClassPK(long classPK) {
265                    return getPersistence().fetchByClassPK(classPK);
266            }
267    
268            /**
269            * Returns the d d m storage link where classPK = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
270            *
271            * @param classPK the class p k
272            * @param retrieveFromCache whether to use the finder cache
273            * @return the matching d d m storage link, or <code>null</code> if a matching d d m storage link could not be found
274            */
275            public static DDMStorageLink fetchByClassPK(long classPK,
276                    boolean retrieveFromCache) {
277                    return getPersistence().fetchByClassPK(classPK, retrieveFromCache);
278            }
279    
280            /**
281            * Removes the d d m storage link where classPK = &#63; from the database.
282            *
283            * @param classPK the class p k
284            * @return the d d m storage link that was removed
285            */
286            public static DDMStorageLink removeByClassPK(long classPK)
287                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStorageLinkException {
288                    return getPersistence().removeByClassPK(classPK);
289            }
290    
291            /**
292            * Returns the number of d d m storage links where classPK = &#63;.
293            *
294            * @param classPK the class p k
295            * @return the number of matching d d m storage links
296            */
297            public static int countByClassPK(long classPK) {
298                    return getPersistence().countByClassPK(classPK);
299            }
300    
301            /**
302            * Returns all the d d m storage links where structureId = &#63;.
303            *
304            * @param structureId the structure ID
305            * @return the matching d d m storage links
306            */
307            public static List<DDMStorageLink> findByStructureId(long structureId) {
308                    return getPersistence().findByStructureId(structureId);
309            }
310    
311            /**
312            * Returns a range of all the d d m storage links where structureId = &#63;.
313            *
314            * <p>
315            * 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 DDMStorageLinkModelImpl}. 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.
316            * </p>
317            *
318            * @param structureId the structure ID
319            * @param start the lower bound of the range of d d m storage links
320            * @param end the upper bound of the range of d d m storage links (not inclusive)
321            * @return the range of matching d d m storage links
322            */
323            public static List<DDMStorageLink> findByStructureId(long structureId,
324                    int start, int end) {
325                    return getPersistence().findByStructureId(structureId, start, end);
326            }
327    
328            /**
329            * Returns an ordered range of all the d d m storage links where structureId = &#63;.
330            *
331            * <p>
332            * 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 DDMStorageLinkModelImpl}. 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.
333            * </p>
334            *
335            * @param structureId the structure ID
336            * @param start the lower bound of the range of d d m storage links
337            * @param end the upper bound of the range of d d m storage links (not inclusive)
338            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
339            * @return the ordered range of matching d d m storage links
340            */
341            public static List<DDMStorageLink> findByStructureId(long structureId,
342                    int start, int end, OrderByComparator<DDMStorageLink> orderByComparator) {
343                    return getPersistence()
344                                       .findByStructureId(structureId, start, end, orderByComparator);
345            }
346    
347            /**
348            * Returns the first d d m storage link in the ordered set where structureId = &#63;.
349            *
350            * @param structureId the structure ID
351            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
352            * @return the first matching d d m storage link
353            * @throws NoSuchStorageLinkException if a matching d d m storage link could not be found
354            */
355            public static DDMStorageLink findByStructureId_First(long structureId,
356                    OrderByComparator<DDMStorageLink> orderByComparator)
357                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStorageLinkException {
358                    return getPersistence()
359                                       .findByStructureId_First(structureId, orderByComparator);
360            }
361    
362            /**
363            * Returns the first d d m storage link in the ordered set where structureId = &#63;.
364            *
365            * @param structureId the structure ID
366            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
367            * @return the first matching d d m storage link, or <code>null</code> if a matching d d m storage link could not be found
368            */
369            public static DDMStorageLink fetchByStructureId_First(long structureId,
370                    OrderByComparator<DDMStorageLink> orderByComparator) {
371                    return getPersistence()
372                                       .fetchByStructureId_First(structureId, orderByComparator);
373            }
374    
375            /**
376            * Returns the last d d m storage link in the ordered set where structureId = &#63;.
377            *
378            * @param structureId the structure ID
379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
380            * @return the last matching d d m storage link
381            * @throws NoSuchStorageLinkException if a matching d d m storage link could not be found
382            */
383            public static DDMStorageLink findByStructureId_Last(long structureId,
384                    OrderByComparator<DDMStorageLink> orderByComparator)
385                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStorageLinkException {
386                    return getPersistence()
387                                       .findByStructureId_Last(structureId, orderByComparator);
388            }
389    
390            /**
391            * Returns the last d d m storage link in the ordered set where structureId = &#63;.
392            *
393            * @param structureId the structure ID
394            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
395            * @return the last matching d d m storage link, or <code>null</code> if a matching d d m storage link could not be found
396            */
397            public static DDMStorageLink fetchByStructureId_Last(long structureId,
398                    OrderByComparator<DDMStorageLink> orderByComparator) {
399                    return getPersistence()
400                                       .fetchByStructureId_Last(structureId, orderByComparator);
401            }
402    
403            /**
404            * Returns the d d m storage links before and after the current d d m storage link in the ordered set where structureId = &#63;.
405            *
406            * @param storageLinkId the primary key of the current d d m storage link
407            * @param structureId the structure ID
408            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
409            * @return the previous, current, and next d d m storage link
410            * @throws NoSuchStorageLinkException if a d d m storage link with the primary key could not be found
411            */
412            public static DDMStorageLink[] findByStructureId_PrevAndNext(
413                    long storageLinkId, long structureId,
414                    OrderByComparator<DDMStorageLink> orderByComparator)
415                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStorageLinkException {
416                    return getPersistence()
417                                       .findByStructureId_PrevAndNext(storageLinkId, structureId,
418                            orderByComparator);
419            }
420    
421            /**
422            * Removes all the d d m storage links where structureId = &#63; from the database.
423            *
424            * @param structureId the structure ID
425            */
426            public static void removeByStructureId(long structureId) {
427                    getPersistence().removeByStructureId(structureId);
428            }
429    
430            /**
431            * Returns the number of d d m storage links where structureId = &#63;.
432            *
433            * @param structureId the structure ID
434            * @return the number of matching d d m storage links
435            */
436            public static int countByStructureId(long structureId) {
437                    return getPersistence().countByStructureId(structureId);
438            }
439    
440            /**
441            * Caches the d d m storage link in the entity cache if it is enabled.
442            *
443            * @param ddmStorageLink the d d m storage link
444            */
445            public static void cacheResult(DDMStorageLink ddmStorageLink) {
446                    getPersistence().cacheResult(ddmStorageLink);
447            }
448    
449            /**
450            * Caches the d d m storage links in the entity cache if it is enabled.
451            *
452            * @param ddmStorageLinks the d d m storage links
453            */
454            public static void cacheResult(List<DDMStorageLink> ddmStorageLinks) {
455                    getPersistence().cacheResult(ddmStorageLinks);
456            }
457    
458            /**
459            * Creates a new d d m storage link with the primary key. Does not add the d d m storage link to the database.
460            *
461            * @param storageLinkId the primary key for the new d d m storage link
462            * @return the new d d m storage link
463            */
464            public static DDMStorageLink create(long storageLinkId) {
465                    return getPersistence().create(storageLinkId);
466            }
467    
468            /**
469            * Removes the d d m storage link with the primary key from the database. Also notifies the appropriate model listeners.
470            *
471            * @param storageLinkId the primary key of the d d m storage link
472            * @return the d d m storage link that was removed
473            * @throws NoSuchStorageLinkException if a d d m storage link with the primary key could not be found
474            */
475            public static DDMStorageLink remove(long storageLinkId)
476                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStorageLinkException {
477                    return getPersistence().remove(storageLinkId);
478            }
479    
480            public static DDMStorageLink updateImpl(DDMStorageLink ddmStorageLink) {
481                    return getPersistence().updateImpl(ddmStorageLink);
482            }
483    
484            /**
485            * Returns the d d m storage link with the primary key or throws a {@link NoSuchStorageLinkException} if it could not be found.
486            *
487            * @param storageLinkId the primary key of the d d m storage link
488            * @return the d d m storage link
489            * @throws NoSuchStorageLinkException if a d d m storage link with the primary key could not be found
490            */
491            public static DDMStorageLink findByPrimaryKey(long storageLinkId)
492                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStorageLinkException {
493                    return getPersistence().findByPrimaryKey(storageLinkId);
494            }
495    
496            /**
497            * Returns the d d m storage link with the primary key or returns <code>null</code> if it could not be found.
498            *
499            * @param storageLinkId the primary key of the d d m storage link
500            * @return the d d m storage link, or <code>null</code> if a d d m storage link with the primary key could not be found
501            */
502            public static DDMStorageLink fetchByPrimaryKey(long storageLinkId) {
503                    return getPersistence().fetchByPrimaryKey(storageLinkId);
504            }
505    
506            public static java.util.Map<java.io.Serializable, DDMStorageLink> fetchByPrimaryKeys(
507                    java.util.Set<java.io.Serializable> primaryKeys) {
508                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
509            }
510    
511            /**
512            * Returns all the d d m storage links.
513            *
514            * @return the d d m storage links
515            */
516            public static List<DDMStorageLink> findAll() {
517                    return getPersistence().findAll();
518            }
519    
520            /**
521            * Returns a range of all the d d m storage links.
522            *
523            * <p>
524            * 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 DDMStorageLinkModelImpl}. 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.
525            * </p>
526            *
527            * @param start the lower bound of the range of d d m storage links
528            * @param end the upper bound of the range of d d m storage links (not inclusive)
529            * @return the range of d d m storage links
530            */
531            public static List<DDMStorageLink> findAll(int start, int end) {
532                    return getPersistence().findAll(start, end);
533            }
534    
535            /**
536            * Returns an ordered range of all the d d m storage links.
537            *
538            * <p>
539            * 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 DDMStorageLinkModelImpl}. 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.
540            * </p>
541            *
542            * @param start the lower bound of the range of d d m storage links
543            * @param end the upper bound of the range of d d m storage links (not inclusive)
544            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
545            * @return the ordered range of d d m storage links
546            */
547            public static List<DDMStorageLink> findAll(int start, int end,
548                    OrderByComparator<DDMStorageLink> orderByComparator) {
549                    return getPersistence().findAll(start, end, orderByComparator);
550            }
551    
552            /**
553            * Removes all the d d m storage links from the database.
554            */
555            public static void removeAll() {
556                    getPersistence().removeAll();
557            }
558    
559            /**
560            * Returns the number of d d m storage links.
561            *
562            * @return the number of d d m storage links
563            */
564            public static int countAll() {
565                    return getPersistence().countAll();
566            }
567    
568            public static DDMStorageLinkPersistence getPersistence() {
569                    if (_persistence == null) {
570                            _persistence = (DDMStorageLinkPersistence)PortalBeanLocatorUtil.locate(DDMStorageLinkPersistence.class.getName());
571    
572                            ReferenceRegistry.registerReference(DDMStorageLinkUtil.class,
573                                    "_persistence");
574                    }
575    
576                    return _persistence;
577            }
578    
579            /**
580             * @deprecated As of 6.2.0
581             */
582            @Deprecated
583            public void setPersistence(DDMStorageLinkPersistence persistence) {
584            }
585    
586            private static DDMStorageLinkPersistence _persistence;
587    }