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.softwarecatalog.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.softwarecatalog.model.SCProductVersion;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the s c product version service. This utility wraps {@link com.liferay.portlet.softwarecatalog.service.persistence.impl.SCProductVersionPersistenceImpl} 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 SCProductVersionPersistence
038     * @see com.liferay.portlet.softwarecatalog.service.persistence.impl.SCProductVersionPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class SCProductVersionUtil {
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(SCProductVersion scProductVersion) {
060                    getPersistence().clearCache(scProductVersion);
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<SCProductVersion> 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<SCProductVersion> 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<SCProductVersion> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<SCProductVersion> 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 SCProductVersion update(SCProductVersion scProductVersion) {
101                    return getPersistence().update(scProductVersion);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static SCProductVersion update(SCProductVersion scProductVersion,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(scProductVersion, serviceContext);
110            }
111    
112            /**
113            * Returns all the s c product versions where productEntryId = &#63;.
114            *
115            * @param productEntryId the product entry ID
116            * @return the matching s c product versions
117            */
118            public static List<SCProductVersion> findByProductEntryId(
119                    long productEntryId) {
120                    return getPersistence().findByProductEntryId(productEntryId);
121            }
122    
123            /**
124            * Returns a range of all the s c product versions where productEntryId = &#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 SCProductVersionModelImpl}. 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 productEntryId the product entry ID
131            * @param start the lower bound of the range of s c product versions
132            * @param end the upper bound of the range of s c product versions (not inclusive)
133            * @return the range of matching s c product versions
134            */
135            public static List<SCProductVersion> findByProductEntryId(
136                    long productEntryId, int start, int end) {
137                    return getPersistence().findByProductEntryId(productEntryId, start, end);
138            }
139    
140            /**
141            * Returns an ordered range of all the s c product versions where productEntryId = &#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 SCProductVersionModelImpl}. 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 productEntryId the product entry ID
148            * @param start the lower bound of the range of s c product versions
149            * @param end the upper bound of the range of s c product versions (not inclusive)
150            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
151            * @return the ordered range of matching s c product versions
152            */
153            public static List<SCProductVersion> findByProductEntryId(
154                    long productEntryId, int start, int end,
155                    OrderByComparator<SCProductVersion> orderByComparator) {
156                    return getPersistence()
157                                       .findByProductEntryId(productEntryId, start, end,
158                            orderByComparator);
159            }
160    
161            /**
162            * Returns an ordered range of all the s c product versions where productEntryId = &#63;.
163            *
164            * <p>
165            * 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 SCProductVersionModelImpl}. 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.
166            * </p>
167            *
168            * @param productEntryId the product entry ID
169            * @param start the lower bound of the range of s c product versions
170            * @param end the upper bound of the range of s c product versions (not inclusive)
171            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
172            * @param retrieveFromCache whether to retrieve from the finder cache
173            * @return the ordered range of matching s c product versions
174            */
175            public static List<SCProductVersion> findByProductEntryId(
176                    long productEntryId, int start, int end,
177                    OrderByComparator<SCProductVersion> orderByComparator,
178                    boolean retrieveFromCache) {
179                    return getPersistence()
180                                       .findByProductEntryId(productEntryId, start, end,
181                            orderByComparator, retrieveFromCache);
182            }
183    
184            /**
185            * Returns the first s c product version in the ordered set where productEntryId = &#63;.
186            *
187            * @param productEntryId the product entry ID
188            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
189            * @return the first matching s c product version
190            * @throws NoSuchProductVersionException if a matching s c product version could not be found
191            */
192            public static SCProductVersion findByProductEntryId_First(
193                    long productEntryId,
194                    OrderByComparator<SCProductVersion> orderByComparator)
195                    throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
196                    return getPersistence()
197                                       .findByProductEntryId_First(productEntryId, orderByComparator);
198            }
199    
200            /**
201            * Returns the first s c product version in the ordered set where productEntryId = &#63;.
202            *
203            * @param productEntryId the product entry ID
204            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
205            * @return the first matching s c product version, or <code>null</code> if a matching s c product version could not be found
206            */
207            public static SCProductVersion fetchByProductEntryId_First(
208                    long productEntryId,
209                    OrderByComparator<SCProductVersion> orderByComparator) {
210                    return getPersistence()
211                                       .fetchByProductEntryId_First(productEntryId,
212                            orderByComparator);
213            }
214    
215            /**
216            * Returns the last s c product version in the ordered set where productEntryId = &#63;.
217            *
218            * @param productEntryId the product entry ID
219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
220            * @return the last matching s c product version
221            * @throws NoSuchProductVersionException if a matching s c product version could not be found
222            */
223            public static SCProductVersion findByProductEntryId_Last(
224                    long productEntryId,
225                    OrderByComparator<SCProductVersion> orderByComparator)
226                    throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
227                    return getPersistence()
228                                       .findByProductEntryId_Last(productEntryId, orderByComparator);
229            }
230    
231            /**
232            * Returns the last s c product version in the ordered set where productEntryId = &#63;.
233            *
234            * @param productEntryId the product entry ID
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the last matching s c product version, or <code>null</code> if a matching s c product version could not be found
237            */
238            public static SCProductVersion fetchByProductEntryId_Last(
239                    long productEntryId,
240                    OrderByComparator<SCProductVersion> orderByComparator) {
241                    return getPersistence()
242                                       .fetchByProductEntryId_Last(productEntryId, orderByComparator);
243            }
244    
245            /**
246            * Returns the s c product versions before and after the current s c product version in the ordered set where productEntryId = &#63;.
247            *
248            * @param productVersionId the primary key of the current s c product version
249            * @param productEntryId the product entry ID
250            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
251            * @return the previous, current, and next s c product version
252            * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found
253            */
254            public static SCProductVersion[] findByProductEntryId_PrevAndNext(
255                    long productVersionId, long productEntryId,
256                    OrderByComparator<SCProductVersion> orderByComparator)
257                    throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
258                    return getPersistence()
259                                       .findByProductEntryId_PrevAndNext(productVersionId,
260                            productEntryId, orderByComparator);
261            }
262    
263            /**
264            * Removes all the s c product versions where productEntryId = &#63; from the database.
265            *
266            * @param productEntryId the product entry ID
267            */
268            public static void removeByProductEntryId(long productEntryId) {
269                    getPersistence().removeByProductEntryId(productEntryId);
270            }
271    
272            /**
273            * Returns the number of s c product versions where productEntryId = &#63;.
274            *
275            * @param productEntryId the product entry ID
276            * @return the number of matching s c product versions
277            */
278            public static int countByProductEntryId(long productEntryId) {
279                    return getPersistence().countByProductEntryId(productEntryId);
280            }
281    
282            /**
283            * Returns the s c product version where directDownloadURL = &#63; or throws a {@link NoSuchProductVersionException} if it could not be found.
284            *
285            * @param directDownloadURL the direct download u r l
286            * @return the matching s c product version
287            * @throws NoSuchProductVersionException if a matching s c product version could not be found
288            */
289            public static SCProductVersion findByDirectDownloadURL(
290                    java.lang.String directDownloadURL)
291                    throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
292                    return getPersistence().findByDirectDownloadURL(directDownloadURL);
293            }
294    
295            /**
296            * Returns the s c product version where directDownloadURL = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
297            *
298            * @param directDownloadURL the direct download u r l
299            * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found
300            */
301            public static SCProductVersion fetchByDirectDownloadURL(
302                    java.lang.String directDownloadURL) {
303                    return getPersistence().fetchByDirectDownloadURL(directDownloadURL);
304            }
305    
306            /**
307            * Returns the s c product version where directDownloadURL = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
308            *
309            * @param directDownloadURL the direct download u r l
310            * @param retrieveFromCache whether to retrieve from the finder cache
311            * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found
312            */
313            public static SCProductVersion fetchByDirectDownloadURL(
314                    java.lang.String directDownloadURL, boolean retrieveFromCache) {
315                    return getPersistence()
316                                       .fetchByDirectDownloadURL(directDownloadURL,
317                            retrieveFromCache);
318            }
319    
320            /**
321            * Removes the s c product version where directDownloadURL = &#63; from the database.
322            *
323            * @param directDownloadURL the direct download u r l
324            * @return the s c product version that was removed
325            */
326            public static SCProductVersion removeByDirectDownloadURL(
327                    java.lang.String directDownloadURL)
328                    throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
329                    return getPersistence().removeByDirectDownloadURL(directDownloadURL);
330            }
331    
332            /**
333            * Returns the number of s c product versions where directDownloadURL = &#63;.
334            *
335            * @param directDownloadURL the direct download u r l
336            * @return the number of matching s c product versions
337            */
338            public static int countByDirectDownloadURL(
339                    java.lang.String directDownloadURL) {
340                    return getPersistence().countByDirectDownloadURL(directDownloadURL);
341            }
342    
343            /**
344            * Caches the s c product version in the entity cache if it is enabled.
345            *
346            * @param scProductVersion the s c product version
347            */
348            public static void cacheResult(SCProductVersion scProductVersion) {
349                    getPersistence().cacheResult(scProductVersion);
350            }
351    
352            /**
353            * Caches the s c product versions in the entity cache if it is enabled.
354            *
355            * @param scProductVersions the s c product versions
356            */
357            public static void cacheResult(List<SCProductVersion> scProductVersions) {
358                    getPersistence().cacheResult(scProductVersions);
359            }
360    
361            /**
362            * Creates a new s c product version with the primary key. Does not add the s c product version to the database.
363            *
364            * @param productVersionId the primary key for the new s c product version
365            * @return the new s c product version
366            */
367            public static SCProductVersion create(long productVersionId) {
368                    return getPersistence().create(productVersionId);
369            }
370    
371            /**
372            * Removes the s c product version with the primary key from the database. Also notifies the appropriate model listeners.
373            *
374            * @param productVersionId the primary key of the s c product version
375            * @return the s c product version that was removed
376            * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found
377            */
378            public static SCProductVersion remove(long productVersionId)
379                    throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
380                    return getPersistence().remove(productVersionId);
381            }
382    
383            public static SCProductVersion updateImpl(SCProductVersion scProductVersion) {
384                    return getPersistence().updateImpl(scProductVersion);
385            }
386    
387            /**
388            * Returns the s c product version with the primary key or throws a {@link NoSuchProductVersionException} if it could not be found.
389            *
390            * @param productVersionId the primary key of the s c product version
391            * @return the s c product version
392            * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found
393            */
394            public static SCProductVersion findByPrimaryKey(long productVersionId)
395                    throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
396                    return getPersistence().findByPrimaryKey(productVersionId);
397            }
398    
399            /**
400            * Returns the s c product version with the primary key or returns <code>null</code> if it could not be found.
401            *
402            * @param productVersionId the primary key of the s c product version
403            * @return the s c product version, or <code>null</code> if a s c product version with the primary key could not be found
404            */
405            public static SCProductVersion fetchByPrimaryKey(long productVersionId) {
406                    return getPersistence().fetchByPrimaryKey(productVersionId);
407            }
408    
409            public static java.util.Map<java.io.Serializable, SCProductVersion> fetchByPrimaryKeys(
410                    java.util.Set<java.io.Serializable> primaryKeys) {
411                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
412            }
413    
414            /**
415            * Returns all the s c product versions.
416            *
417            * @return the s c product versions
418            */
419            public static List<SCProductVersion> findAll() {
420                    return getPersistence().findAll();
421            }
422    
423            /**
424            * Returns a range of all the s c product versions.
425            *
426            * <p>
427            * 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 SCProductVersionModelImpl}. 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.
428            * </p>
429            *
430            * @param start the lower bound of the range of s c product versions
431            * @param end the upper bound of the range of s c product versions (not inclusive)
432            * @return the range of s c product versions
433            */
434            public static List<SCProductVersion> findAll(int start, int end) {
435                    return getPersistence().findAll(start, end);
436            }
437    
438            /**
439            * Returns an ordered range of all the s c product versions.
440            *
441            * <p>
442            * 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 SCProductVersionModelImpl}. 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.
443            * </p>
444            *
445            * @param start the lower bound of the range of s c product versions
446            * @param end the upper bound of the range of s c product versions (not inclusive)
447            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
448            * @return the ordered range of s c product versions
449            */
450            public static List<SCProductVersion> findAll(int start, int end,
451                    OrderByComparator<SCProductVersion> orderByComparator) {
452                    return getPersistence().findAll(start, end, orderByComparator);
453            }
454    
455            /**
456            * Returns an ordered range of all the s c product versions.
457            *
458            * <p>
459            * 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 SCProductVersionModelImpl}. 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.
460            * </p>
461            *
462            * @param start the lower bound of the range of s c product versions
463            * @param end the upper bound of the range of s c product versions (not inclusive)
464            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
465            * @param retrieveFromCache whether to retrieve from the finder cache
466            * @return the ordered range of s c product versions
467            */
468            public static List<SCProductVersion> findAll(int start, int end,
469                    OrderByComparator<SCProductVersion> orderByComparator,
470                    boolean retrieveFromCache) {
471                    return getPersistence()
472                                       .findAll(start, end, orderByComparator, retrieveFromCache);
473            }
474    
475            /**
476            * Removes all the s c product versions from the database.
477            */
478            public static void removeAll() {
479                    getPersistence().removeAll();
480            }
481    
482            /**
483            * Returns the number of s c product versions.
484            *
485            * @return the number of s c product versions
486            */
487            public static int countAll() {
488                    return getPersistence().countAll();
489            }
490    
491            /**
492            * Returns the primaryKeys of s c framework versions associated with the s c product version.
493            *
494            * @param pk the primary key of the s c product version
495            * @return long[] of the primaryKeys of s c framework versions associated with the s c product version
496            */
497            public static long[] getSCFrameworkVersionPrimaryKeys(long pk) {
498                    return getPersistence().getSCFrameworkVersionPrimaryKeys(pk);
499            }
500    
501            /**
502            * Returns all the s c framework versions associated with the s c product version.
503            *
504            * @param pk the primary key of the s c product version
505            * @return the s c framework versions associated with the s c product version
506            */
507            public static List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
508                    long pk) {
509                    return getPersistence().getSCFrameworkVersions(pk);
510            }
511    
512            /**
513            * Returns a range of all the s c framework versions associated with the s c product version.
514            *
515            * <p>
516            * 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 SCProductVersionModelImpl}. 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.
517            * </p>
518            *
519            * @param pk the primary key of the s c product version
520            * @param start the lower bound of the range of s c product versions
521            * @param end the upper bound of the range of s c product versions (not inclusive)
522            * @return the range of s c framework versions associated with the s c product version
523            */
524            public static List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
525                    long pk, int start, int end) {
526                    return getPersistence().getSCFrameworkVersions(pk, start, end);
527            }
528    
529            /**
530            * Returns an ordered range of all the s c framework versions associated with the s c product version.
531            *
532            * <p>
533            * 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 SCProductVersionModelImpl}. 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.
534            * </p>
535            *
536            * @param pk the primary key of the s c product version
537            * @param start the lower bound of the range of s c product versions
538            * @param end the upper bound of the range of s c product versions (not inclusive)
539            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
540            * @return the ordered range of s c framework versions associated with the s c product version
541            */
542            public static List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
543                    long pk, int start, int end,
544                    OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> orderByComparator) {
545                    return getPersistence()
546                                       .getSCFrameworkVersions(pk, start, end, orderByComparator);
547            }
548    
549            /**
550            * Returns the number of s c framework versions associated with the s c product version.
551            *
552            * @param pk the primary key of the s c product version
553            * @return the number of s c framework versions associated with the s c product version
554            */
555            public static int getSCFrameworkVersionsSize(long pk) {
556                    return getPersistence().getSCFrameworkVersionsSize(pk);
557            }
558    
559            /**
560            * Returns <code>true</code> if the s c framework version is associated with the s c product version.
561            *
562            * @param pk the primary key of the s c product version
563            * @param scFrameworkVersionPK the primary key of the s c framework version
564            * @return <code>true</code> if the s c framework version is associated with the s c product version; <code>false</code> otherwise
565            */
566            public static boolean containsSCFrameworkVersion(long pk,
567                    long scFrameworkVersionPK) {
568                    return getPersistence()
569                                       .containsSCFrameworkVersion(pk, scFrameworkVersionPK);
570            }
571    
572            /**
573            * Returns <code>true</code> if the s c product version has any s c framework versions associated with it.
574            *
575            * @param pk the primary key of the s c product version to check for associations with s c framework versions
576            * @return <code>true</code> if the s c product version has any s c framework versions associated with it; <code>false</code> otherwise
577            */
578            public static boolean containsSCFrameworkVersions(long pk) {
579                    return getPersistence().containsSCFrameworkVersions(pk);
580            }
581    
582            /**
583            * Adds an association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
584            *
585            * @param pk the primary key of the s c product version
586            * @param scFrameworkVersionPK the primary key of the s c framework version
587            */
588            public static void addSCFrameworkVersion(long pk, long scFrameworkVersionPK) {
589                    getPersistence().addSCFrameworkVersion(pk, scFrameworkVersionPK);
590            }
591    
592            /**
593            * Adds an association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
594            *
595            * @param pk the primary key of the s c product version
596            * @param scFrameworkVersion the s c framework version
597            */
598            public static void addSCFrameworkVersion(long pk,
599                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) {
600                    getPersistence().addSCFrameworkVersion(pk, scFrameworkVersion);
601            }
602    
603            /**
604            * Adds an association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
605            *
606            * @param pk the primary key of the s c product version
607            * @param scFrameworkVersionPKs the primary keys of the s c framework versions
608            */
609            public static void addSCFrameworkVersions(long pk,
610                    long[] scFrameworkVersionPKs) {
611                    getPersistence().addSCFrameworkVersions(pk, scFrameworkVersionPKs);
612            }
613    
614            /**
615            * Adds an association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
616            *
617            * @param pk the primary key of the s c product version
618            * @param scFrameworkVersions the s c framework versions
619            */
620            public static void addSCFrameworkVersions(long pk,
621                    List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) {
622                    getPersistence().addSCFrameworkVersions(pk, scFrameworkVersions);
623            }
624    
625            /**
626            * Clears all associations between the s c product version and its s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
627            *
628            * @param pk the primary key of the s c product version to clear the associated s c framework versions from
629            */
630            public static void clearSCFrameworkVersions(long pk) {
631                    getPersistence().clearSCFrameworkVersions(pk);
632            }
633    
634            /**
635            * Removes the association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
636            *
637            * @param pk the primary key of the s c product version
638            * @param scFrameworkVersionPK the primary key of the s c framework version
639            */
640            public static void removeSCFrameworkVersion(long pk,
641                    long scFrameworkVersionPK) {
642                    getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersionPK);
643            }
644    
645            /**
646            * Removes the association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
647            *
648            * @param pk the primary key of the s c product version
649            * @param scFrameworkVersion the s c framework version
650            */
651            public static void removeSCFrameworkVersion(long pk,
652                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) {
653                    getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersion);
654            }
655    
656            /**
657            * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
658            *
659            * @param pk the primary key of the s c product version
660            * @param scFrameworkVersionPKs the primary keys of the s c framework versions
661            */
662            public static void removeSCFrameworkVersions(long pk,
663                    long[] scFrameworkVersionPKs) {
664                    getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersionPKs);
665            }
666    
667            /**
668            * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
669            *
670            * @param pk the primary key of the s c product version
671            * @param scFrameworkVersions the s c framework versions
672            */
673            public static void removeSCFrameworkVersions(long pk,
674                    List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) {
675                    getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersions);
676            }
677    
678            /**
679            * Sets the s c framework versions associated with the s c product version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
680            *
681            * @param pk the primary key of the s c product version
682            * @param scFrameworkVersionPKs the primary keys of the s c framework versions to be associated with the s c product version
683            */
684            public static void setSCFrameworkVersions(long pk,
685                    long[] scFrameworkVersionPKs) {
686                    getPersistence().setSCFrameworkVersions(pk, scFrameworkVersionPKs);
687            }
688    
689            /**
690            * Sets the s c framework versions associated with the s c product version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
691            *
692            * @param pk the primary key of the s c product version
693            * @param scFrameworkVersions the s c framework versions to be associated with the s c product version
694            */
695            public static void setSCFrameworkVersions(long pk,
696                    List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) {
697                    getPersistence().setSCFrameworkVersions(pk, scFrameworkVersions);
698            }
699    
700            public static SCProductVersionPersistence getPersistence() {
701                    if (_persistence == null) {
702                            _persistence = (SCProductVersionPersistence)PortalBeanLocatorUtil.locate(SCProductVersionPersistence.class.getName());
703    
704                            ReferenceRegistry.registerReference(SCProductVersionUtil.class,
705                                    "_persistence");
706                    }
707    
708                    return _persistence;
709            }
710    
711            /**
712             * @deprecated As of 6.2.0
713             */
714            @Deprecated
715            public void setPersistence(SCProductVersionPersistence persistence) {
716            }
717    
718            private static SCProductVersionPersistence _persistence;
719    }