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