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 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 NoSuchProductVersionException if a matching s c product version could not be found
168            */
169            public static SCProductVersion findByProductEntryId_First(
170                    long productEntryId,
171                    OrderByComparator<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 SCProductVersion fetchByProductEntryId_First(
185                    long productEntryId,
186                    OrderByComparator<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 NoSuchProductVersionException if a matching s c product version could not be found
199            */
200            public static SCProductVersion findByProductEntryId_Last(
201                    long productEntryId,
202                    OrderByComparator<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 SCProductVersion fetchByProductEntryId_Last(
216                    long productEntryId,
217                    OrderByComparator<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 NoSuchProductVersionException if a s c product version with the primary key could not be found
230            */
231            public static SCProductVersion[] findByProductEntryId_PrevAndNext(
232                    long productVersionId, long productEntryId,
233                    OrderByComparator<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 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 NoSuchProductVersionException if a matching s c product version could not be found
265            */
266            public static 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 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 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 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(SCProductVersion scProductVersion) {
326                    getPersistence().cacheResult(scProductVersion);
327            }
328    
329            /**
330            * Caches the s c product versions in the entity cache if it is enabled.
331            *
332            * @param scProductVersions the s c product versions
333            */
334            public static void cacheResult(List<SCProductVersion> scProductVersions) {
335                    getPersistence().cacheResult(scProductVersions);
336            }
337    
338            /**
339            * Creates a new s c product version with the primary key. Does not add the s c product version to the database.
340            *
341            * @param productVersionId the primary key for the new s c product version
342            * @return the new s c product version
343            */
344            public static SCProductVersion create(long productVersionId) {
345                    return getPersistence().create(productVersionId);
346            }
347    
348            /**
349            * Removes the s c product version with the primary key from the database. Also notifies the appropriate model listeners.
350            *
351            * @param productVersionId the primary key of the s c product version
352            * @return the s c product version that was removed
353            * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found
354            */
355            public static SCProductVersion remove(long productVersionId)
356                    throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
357                    return getPersistence().remove(productVersionId);
358            }
359    
360            public static SCProductVersion updateImpl(SCProductVersion scProductVersion) {
361                    return getPersistence().updateImpl(scProductVersion);
362            }
363    
364            /**
365            * Returns the s c product version with the primary key or throws a {@link NoSuchProductVersionException} if it could not be found.
366            *
367            * @param productVersionId the primary key of the s c product version
368            * @return the s c product version
369            * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found
370            */
371            public static SCProductVersion findByPrimaryKey(long productVersionId)
372                    throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
373                    return getPersistence().findByPrimaryKey(productVersionId);
374            }
375    
376            /**
377            * Returns the s c product version with the primary key or returns <code>null</code> if it could not be found.
378            *
379            * @param productVersionId the primary key of the s c product version
380            * @return the s c product version, or <code>null</code> if a s c product version with the primary key could not be found
381            */
382            public static SCProductVersion fetchByPrimaryKey(long productVersionId) {
383                    return getPersistence().fetchByPrimaryKey(productVersionId);
384            }
385    
386            public static java.util.Map<java.io.Serializable, SCProductVersion> fetchByPrimaryKeys(
387                    java.util.Set<java.io.Serializable> primaryKeys) {
388                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
389            }
390    
391            /**
392            * Returns all the s c product versions.
393            *
394            * @return the s c product versions
395            */
396            public static List<SCProductVersion> findAll() {
397                    return getPersistence().findAll();
398            }
399    
400            /**
401            * Returns a range of all the s c product versions.
402            *
403            * <p>
404            * 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.
405            * </p>
406            *
407            * @param start the lower bound of the range of s c product versions
408            * @param end the upper bound of the range of s c product versions (not inclusive)
409            * @return the range of s c product versions
410            */
411            public static List<SCProductVersion> findAll(int start, int end) {
412                    return getPersistence().findAll(start, end);
413            }
414    
415            /**
416            * Returns an ordered range of all the s c product versions.
417            *
418            * <p>
419            * 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.
420            * </p>
421            *
422            * @param start the lower bound of the range of s c product versions
423            * @param end the upper bound of the range of s c product versions (not inclusive)
424            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
425            * @return the ordered range of s c product versions
426            */
427            public static List<SCProductVersion> findAll(int start, int end,
428                    OrderByComparator<SCProductVersion> orderByComparator) {
429                    return getPersistence().findAll(start, end, orderByComparator);
430            }
431    
432            /**
433            * Removes all the s c product versions from the database.
434            */
435            public static void removeAll() {
436                    getPersistence().removeAll();
437            }
438    
439            /**
440            * Returns the number of s c product versions.
441            *
442            * @return the number of s c product versions
443            */
444            public static int countAll() {
445                    return getPersistence().countAll();
446            }
447    
448            /**
449            * Returns the primaryKeys of s c framework versions associated with the s c product version.
450            *
451            * @param pk the primary key of the s c product version
452            * @return long[] of the primaryKeys of s c framework versions associated with the s c product version
453            */
454            public static long[] getSCFrameworkVersionPrimaryKeys(long pk) {
455                    return getPersistence().getSCFrameworkVersionPrimaryKeys(pk);
456            }
457    
458            /**
459            * Returns all the s c framework versions associated with the s c product version.
460            *
461            * @param pk the primary key of the s c product version
462            * @return the s c framework versions associated with the s c product version
463            */
464            public static List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
465                    long pk) {
466                    return getPersistence().getSCFrameworkVersions(pk);
467            }
468    
469            /**
470            * Returns a range of all the s c framework versions associated with the s c product version.
471            *
472            * <p>
473            * 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.
474            * </p>
475            *
476            * @param pk the primary key of the s c product version
477            * @param start the lower bound of the range of s c product versions
478            * @param end the upper bound of the range of s c product versions (not inclusive)
479            * @return the range of s c framework versions associated with the s c product version
480            */
481            public static List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
482                    long pk, int start, int end) {
483                    return getPersistence().getSCFrameworkVersions(pk, start, end);
484            }
485    
486            /**
487            * Returns an ordered range of all the s c framework versions associated with the s c product version.
488            *
489            * <p>
490            * 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.
491            * </p>
492            *
493            * @param pk the primary key of the s c product version
494            * @param start the lower bound of the range of s c product versions
495            * @param end the upper bound of the range of s c product versions (not inclusive)
496            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
497            * @return the ordered range of s c framework versions associated with the s c product version
498            */
499            public static List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
500                    long pk, int start, int end,
501                    OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> orderByComparator) {
502                    return getPersistence()
503                                       .getSCFrameworkVersions(pk, start, end, orderByComparator);
504            }
505    
506            /**
507            * Returns the number of s c framework versions associated with the s c product version.
508            *
509            * @param pk the primary key of the s c product version
510            * @return the number of s c framework versions associated with the s c product version
511            */
512            public static int getSCFrameworkVersionsSize(long pk) {
513                    return getPersistence().getSCFrameworkVersionsSize(pk);
514            }
515    
516            /**
517            * Returns <code>true</code> if the s c framework version is associated with the s c product version.
518            *
519            * @param pk the primary key of the s c product version
520            * @param scFrameworkVersionPK the primary key of the s c framework version
521            * @return <code>true</code> if the s c framework version is associated with the s c product version; <code>false</code> otherwise
522            */
523            public static boolean containsSCFrameworkVersion(long pk,
524                    long scFrameworkVersionPK) {
525                    return getPersistence()
526                                       .containsSCFrameworkVersion(pk, scFrameworkVersionPK);
527            }
528    
529            /**
530            * Returns <code>true</code> if the s c product version has any s c framework versions associated with it.
531            *
532            * @param pk the primary key of the s c product version to check for associations with s c framework versions
533            * @return <code>true</code> if the s c product version has any s c framework versions associated with it; <code>false</code> otherwise
534            */
535            public static boolean containsSCFrameworkVersions(long pk) {
536                    return getPersistence().containsSCFrameworkVersions(pk);
537            }
538    
539            /**
540            * 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.
541            *
542            * @param pk the primary key of the s c product version
543            * @param scFrameworkVersionPK the primary key of the s c framework version
544            */
545            public static void addSCFrameworkVersion(long pk, long scFrameworkVersionPK) {
546                    getPersistence().addSCFrameworkVersion(pk, scFrameworkVersionPK);
547            }
548    
549            /**
550            * 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.
551            *
552            * @param pk the primary key of the s c product version
553            * @param scFrameworkVersion the s c framework version
554            */
555            public static void addSCFrameworkVersion(long pk,
556                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) {
557                    getPersistence().addSCFrameworkVersion(pk, scFrameworkVersion);
558            }
559    
560            /**
561            * 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.
562            *
563            * @param pk the primary key of the s c product version
564            * @param scFrameworkVersionPKs the primary keys of the s c framework versions
565            */
566            public static void addSCFrameworkVersions(long pk,
567                    long[] scFrameworkVersionPKs) {
568                    getPersistence().addSCFrameworkVersions(pk, scFrameworkVersionPKs);
569            }
570    
571            /**
572            * 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.
573            *
574            * @param pk the primary key of the s c product version
575            * @param scFrameworkVersions the s c framework versions
576            */
577            public static void addSCFrameworkVersions(long pk,
578                    List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) {
579                    getPersistence().addSCFrameworkVersions(pk, scFrameworkVersions);
580            }
581    
582            /**
583            * 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.
584            *
585            * @param pk the primary key of the s c product version to clear the associated s c framework versions from
586            */
587            public static void clearSCFrameworkVersions(long pk) {
588                    getPersistence().clearSCFrameworkVersions(pk);
589            }
590    
591            /**
592            * 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.
593            *
594            * @param pk the primary key of the s c product version
595            * @param scFrameworkVersionPK the primary key of the s c framework version
596            */
597            public static void removeSCFrameworkVersion(long pk,
598                    long scFrameworkVersionPK) {
599                    getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersionPK);
600            }
601    
602            /**
603            * 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.
604            *
605            * @param pk the primary key of the s c product version
606            * @param scFrameworkVersion the s c framework version
607            */
608            public static void removeSCFrameworkVersion(long pk,
609                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) {
610                    getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersion);
611            }
612    
613            /**
614            * 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.
615            *
616            * @param pk the primary key of the s c product version
617            * @param scFrameworkVersionPKs the primary keys of the s c framework versions
618            */
619            public static void removeSCFrameworkVersions(long pk,
620                    long[] scFrameworkVersionPKs) {
621                    getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersionPKs);
622            }
623    
624            /**
625            * 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.
626            *
627            * @param pk the primary key of the s c product version
628            * @param scFrameworkVersions the s c framework versions
629            */
630            public static void removeSCFrameworkVersions(long pk,
631                    List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) {
632                    getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersions);
633            }
634    
635            /**
636            * 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.
637            *
638            * @param pk the primary key of the s c product version
639            * @param scFrameworkVersionPKs the primary keys of the s c framework versions to be associated with the s c product version
640            */
641            public static void setSCFrameworkVersions(long pk,
642                    long[] scFrameworkVersionPKs) {
643                    getPersistence().setSCFrameworkVersions(pk, scFrameworkVersionPKs);
644            }
645    
646            /**
647            * 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.
648            *
649            * @param pk the primary key of the s c product version
650            * @param scFrameworkVersions the s c framework versions to be associated with the s c product version
651            */
652            public static void setSCFrameworkVersions(long pk,
653                    List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) {
654                    getPersistence().setSCFrameworkVersions(pk, scFrameworkVersions);
655            }
656    
657            public static SCProductVersionPersistence getPersistence() {
658                    if (_persistence == null) {
659                            _persistence = (SCProductVersionPersistence)PortalBeanLocatorUtil.locate(SCProductVersionPersistence.class.getName());
660    
661                            ReferenceRegistry.registerReference(SCProductVersionUtil.class,
662                                    "_persistence");
663                    }
664    
665                    return _persistence;
666            }
667    
668            /**
669             * @deprecated As of 6.2.0
670             */
671            @Deprecated
672            public void setPersistence(SCProductVersionPersistence persistence) {
673            }
674    
675            private static SCProductVersionPersistence _persistence;
676    }