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