001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.softwarecatalog.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.softwarecatalog.model.SCProductVersion;
025    
026    import java.util.List;
027    
028    /**
029     * 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.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see SCProductVersionPersistence
037     * @see SCProductVersionPersistenceImpl
038     * @generated
039     */
040    public class SCProductVersionUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(SCProductVersion scProductVersion) {
058                    getPersistence().clearCache(scProductVersion);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<SCProductVersion> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<SCProductVersion> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
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 orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
099             */
100            public static SCProductVersion remove(SCProductVersion scProductVersion)
101                    throws SystemException {
102                    return getPersistence().remove(scProductVersion);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
107             */
108            public static SCProductVersion update(SCProductVersion scProductVersion,
109                    boolean merge) throws SystemException {
110                    return getPersistence().update(scProductVersion, merge);
111            }
112    
113            /**
114             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
115             */
116            public static SCProductVersion update(SCProductVersion scProductVersion,
117                    boolean merge, ServiceContext serviceContext) throws SystemException {
118                    return getPersistence().update(scProductVersion, merge, serviceContext);
119            }
120    
121            /**
122            * Caches the s c product version in the entity cache if it is enabled.
123            *
124            * @param scProductVersion the s c product version
125            */
126            public static void cacheResult(
127                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) {
128                    getPersistence().cacheResult(scProductVersion);
129            }
130    
131            /**
132            * Caches the s c product versions in the entity cache if it is enabled.
133            *
134            * @param scProductVersions the s c product versions
135            */
136            public static void cacheResult(
137                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) {
138                    getPersistence().cacheResult(scProductVersions);
139            }
140    
141            /**
142            * Creates a new s c product version with the primary key. Does not add the s c product version to the database.
143            *
144            * @param productVersionId the primary key for the new s c product version
145            * @return the new s c product version
146            */
147            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion create(
148                    long productVersionId) {
149                    return getPersistence().create(productVersionId);
150            }
151    
152            /**
153            * Removes the s c product version with the primary key from the database. Also notifies the appropriate model listeners.
154            *
155            * @param productVersionId the primary key of the s c product version
156            * @return the s c product version that was removed
157            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found
158            * @throws SystemException if a system exception occurred
159            */
160            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion remove(
161                    long productVersionId)
162                    throws com.liferay.portal.kernel.exception.SystemException,
163                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
164                    return getPersistence().remove(productVersionId);
165            }
166    
167            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion updateImpl(
168                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion,
169                    boolean merge)
170                    throws com.liferay.portal.kernel.exception.SystemException {
171                    return getPersistence().updateImpl(scProductVersion, merge);
172            }
173    
174            /**
175            * 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.
176            *
177            * @param productVersionId the primary key of the s c product version
178            * @return the s c product version
179            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found
180            * @throws SystemException if a system exception occurred
181            */
182            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByPrimaryKey(
183                    long productVersionId)
184                    throws com.liferay.portal.kernel.exception.SystemException,
185                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
186                    return getPersistence().findByPrimaryKey(productVersionId);
187            }
188    
189            /**
190            * Returns the s c product version with the primary key or returns <code>null</code> if it could not be found.
191            *
192            * @param productVersionId the primary key of the s c product version
193            * @return the s c product version, or <code>null</code> if a s c product version with the primary key could not be found
194            * @throws SystemException if a system exception occurred
195            */
196            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByPrimaryKey(
197                    long productVersionId)
198                    throws com.liferay.portal.kernel.exception.SystemException {
199                    return getPersistence().fetchByPrimaryKey(productVersionId);
200            }
201    
202            /**
203            * Returns all the s c product versions where productEntryId = &#63;.
204            *
205            * @param productEntryId the product entry ID
206            * @return the matching s c product versions
207            * @throws SystemException if a system exception occurred
208            */
209            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId(
210                    long productEntryId)
211                    throws com.liferay.portal.kernel.exception.SystemException {
212                    return getPersistence().findByProductEntryId(productEntryId);
213            }
214    
215            /**
216            * Returns a range of all the s c product versions where productEntryId = &#63;.
217            *
218            * <p>
219            * 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.
220            * </p>
221            *
222            * @param productEntryId the product entry ID
223            * @param start the lower bound of the range of s c product versions
224            * @param end the upper bound of the range of s c product versions (not inclusive)
225            * @return the range of matching s c product versions
226            * @throws SystemException if a system exception occurred
227            */
228            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId(
229                    long productEntryId, int start, int end)
230                    throws com.liferay.portal.kernel.exception.SystemException {
231                    return getPersistence().findByProductEntryId(productEntryId, start, end);
232            }
233    
234            /**
235            * Returns an ordered range of all the s c product versions where productEntryId = &#63;.
236            *
237            * <p>
238            * 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.
239            * </p>
240            *
241            * @param productEntryId the product entry ID
242            * @param start the lower bound of the range of s c product versions
243            * @param end the upper bound of the range of s c product versions (not inclusive)
244            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
245            * @return the ordered range of matching s c product versions
246            * @throws SystemException if a system exception occurred
247            */
248            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId(
249                    long productEntryId, int start, int end,
250                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
251                    throws com.liferay.portal.kernel.exception.SystemException {
252                    return getPersistence()
253                                       .findByProductEntryId(productEntryId, start, end,
254                            orderByComparator);
255            }
256    
257            /**
258            * Returns the first s c product version in the ordered set where productEntryId = &#63;.
259            *
260            * <p>
261            * 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.
262            * </p>
263            *
264            * @param productEntryId the product entry ID
265            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
266            * @return the first matching s c product version
267            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found
268            * @throws SystemException if a system exception occurred
269            */
270            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByProductEntryId_First(
271                    long productEntryId,
272                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
273                    throws com.liferay.portal.kernel.exception.SystemException,
274                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
275                    return getPersistence()
276                                       .findByProductEntryId_First(productEntryId, orderByComparator);
277            }
278    
279            /**
280            * Returns the last s c product version in the ordered set where productEntryId = &#63;.
281            *
282            * <p>
283            * 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.
284            * </p>
285            *
286            * @param productEntryId the product entry ID
287            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
288            * @return the last matching s c product version
289            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found
290            * @throws SystemException if a system exception occurred
291            */
292            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByProductEntryId_Last(
293                    long productEntryId,
294                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
295                    throws com.liferay.portal.kernel.exception.SystemException,
296                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
297                    return getPersistence()
298                                       .findByProductEntryId_Last(productEntryId, orderByComparator);
299            }
300    
301            /**
302            * Returns the s c product versions before and after the current s c product version in the ordered set where productEntryId = &#63;.
303            *
304            * <p>
305            * 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.
306            * </p>
307            *
308            * @param productVersionId the primary key of the current s c product version
309            * @param productEntryId the product entry ID
310            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
311            * @return the previous, current, and next s c product version
312            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found
313            * @throws SystemException if a system exception occurred
314            */
315            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion[] findByProductEntryId_PrevAndNext(
316                    long productVersionId, long productEntryId,
317                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
318                    throws com.liferay.portal.kernel.exception.SystemException,
319                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
320                    return getPersistence()
321                                       .findByProductEntryId_PrevAndNext(productVersionId,
322                            productEntryId, orderByComparator);
323            }
324    
325            /**
326            * Returns the s c product version where directDownloadURL = &#63; or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchProductVersionException} if it could not be found.
327            *
328            * @param directDownloadURL the direct download u r l
329            * @return the matching s c product version
330            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found
331            * @throws SystemException if a system exception occurred
332            */
333            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByDirectDownloadURL(
334                    java.lang.String directDownloadURL)
335                    throws com.liferay.portal.kernel.exception.SystemException,
336                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
337                    return getPersistence().findByDirectDownloadURL(directDownloadURL);
338            }
339    
340            /**
341            * Returns the s c product version where directDownloadURL = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
342            *
343            * @param directDownloadURL the direct download u r l
344            * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found
345            * @throws SystemException if a system exception occurred
346            */
347            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL(
348                    java.lang.String directDownloadURL)
349                    throws com.liferay.portal.kernel.exception.SystemException {
350                    return getPersistence().fetchByDirectDownloadURL(directDownloadURL);
351            }
352    
353            /**
354            * 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.
355            *
356            * @param directDownloadURL the direct download u r l
357            * @param retrieveFromCache whether to use the finder cache
358            * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found
359            * @throws SystemException if a system exception occurred
360            */
361            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL(
362                    java.lang.String directDownloadURL, boolean retrieveFromCache)
363                    throws com.liferay.portal.kernel.exception.SystemException {
364                    return getPersistence()
365                                       .fetchByDirectDownloadURL(directDownloadURL,
366                            retrieveFromCache);
367            }
368    
369            /**
370            * Returns all the s c product versions.
371            *
372            * @return the s c product versions
373            * @throws SystemException if a system exception occurred
374            */
375            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll()
376                    throws com.liferay.portal.kernel.exception.SystemException {
377                    return getPersistence().findAll();
378            }
379    
380            /**
381            * Returns a range of all the s c product versions.
382            *
383            * <p>
384            * 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.
385            * </p>
386            *
387            * @param start the lower bound of the range of s c product versions
388            * @param end the upper bound of the range of s c product versions (not inclusive)
389            * @return the range of s c product versions
390            * @throws SystemException if a system exception occurred
391            */
392            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll(
393                    int start, int end)
394                    throws com.liferay.portal.kernel.exception.SystemException {
395                    return getPersistence().findAll(start, end);
396            }
397    
398            /**
399            * Returns an ordered range of all the s c product versions.
400            *
401            * <p>
402            * 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.
403            * </p>
404            *
405            * @param start the lower bound of the range of s c product versions
406            * @param end the upper bound of the range of s c product versions (not inclusive)
407            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
408            * @return the ordered range of s c product versions
409            * @throws SystemException if a system exception occurred
410            */
411            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll(
412                    int start, int end,
413                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
414                    throws com.liferay.portal.kernel.exception.SystemException {
415                    return getPersistence().findAll(start, end, orderByComparator);
416            }
417    
418            /**
419            * Removes all the s c product versions where productEntryId = &#63; from the database.
420            *
421            * @param productEntryId the product entry ID
422            * @throws SystemException if a system exception occurred
423            */
424            public static void removeByProductEntryId(long productEntryId)
425                    throws com.liferay.portal.kernel.exception.SystemException {
426                    getPersistence().removeByProductEntryId(productEntryId);
427            }
428    
429            /**
430            * Removes the s c product version where directDownloadURL = &#63; from the database.
431            *
432            * @param directDownloadURL the direct download u r l
433            * @throws SystemException if a system exception occurred
434            */
435            public static void removeByDirectDownloadURL(
436                    java.lang.String directDownloadURL)
437                    throws com.liferay.portal.kernel.exception.SystemException,
438                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
439                    getPersistence().removeByDirectDownloadURL(directDownloadURL);
440            }
441    
442            /**
443            * Removes all the s c product versions from the database.
444            *
445            * @throws SystemException if a system exception occurred
446            */
447            public static void removeAll()
448                    throws com.liferay.portal.kernel.exception.SystemException {
449                    getPersistence().removeAll();
450            }
451    
452            /**
453            * Returns the number of s c product versions where productEntryId = &#63;.
454            *
455            * @param productEntryId the product entry ID
456            * @return the number of matching s c product versions
457            * @throws SystemException if a system exception occurred
458            */
459            public static int countByProductEntryId(long productEntryId)
460                    throws com.liferay.portal.kernel.exception.SystemException {
461                    return getPersistence().countByProductEntryId(productEntryId);
462            }
463    
464            /**
465            * Returns the number of s c product versions where directDownloadURL = &#63;.
466            *
467            * @param directDownloadURL the direct download u r l
468            * @return the number of matching s c product versions
469            * @throws SystemException if a system exception occurred
470            */
471            public static int countByDirectDownloadURL(
472                    java.lang.String directDownloadURL)
473                    throws com.liferay.portal.kernel.exception.SystemException {
474                    return getPersistence().countByDirectDownloadURL(directDownloadURL);
475            }
476    
477            /**
478            * Returns the number of s c product versions.
479            *
480            * @return the number of s c product versions
481            * @throws SystemException if a system exception occurred
482            */
483            public static int countAll()
484                    throws com.liferay.portal.kernel.exception.SystemException {
485                    return getPersistence().countAll();
486            }
487    
488            /**
489            * Returns all the s c framework versions associated with the s c product version.
490            *
491            * @param pk the primary key of the s c product version
492            * @return the s c framework versions associated with the s c product version
493            * @throws SystemException if a system exception occurred
494            */
495            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
496                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
497                    return getPersistence().getSCFrameworkVersions(pk);
498            }
499    
500            /**
501            * Returns a range of all the s c framework versions associated with the s c product version.
502            *
503            * <p>
504            * 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.
505            * </p>
506            *
507            * @param pk the primary key of the s c product version
508            * @param start the lower bound of the range of s c product versions
509            * @param end the upper bound of the range of s c product versions (not inclusive)
510            * @return the range of s c framework versions associated with the s c product version
511            * @throws SystemException if a system exception occurred
512            */
513            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
514                    long pk, int start, int end)
515                    throws com.liferay.portal.kernel.exception.SystemException {
516                    return getPersistence().getSCFrameworkVersions(pk, start, end);
517            }
518    
519            /**
520            * Returns an ordered range of all the s c framework versions associated with the s c product version.
521            *
522            * <p>
523            * 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.
524            * </p>
525            *
526            * @param pk the primary key of the s c product version
527            * @param start the lower bound of the range of s c product versions
528            * @param end the upper bound of the range of s c product versions (not inclusive)
529            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
530            * @return the ordered range of s c framework versions associated with the s c product version
531            * @throws SystemException if a system exception occurred
532            */
533            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
534                    long pk, int start, int end,
535                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
536                    throws com.liferay.portal.kernel.exception.SystemException {
537                    return getPersistence()
538                                       .getSCFrameworkVersions(pk, start, end, orderByComparator);
539            }
540    
541            /**
542            * Returns the number of s c framework versions associated with the s c product version.
543            *
544            * @param pk the primary key of the s c product version
545            * @return the number of s c framework versions associated with the s c product version
546            * @throws SystemException if a system exception occurred
547            */
548            public static int getSCFrameworkVersionsSize(long pk)
549                    throws com.liferay.portal.kernel.exception.SystemException {
550                    return getPersistence().getSCFrameworkVersionsSize(pk);
551            }
552    
553            /**
554            * Returns <code>true</code> if the s c framework version is associated with the s c product version.
555            *
556            * @param pk the primary key of the s c product version
557            * @param scFrameworkVersionPK the primary key of the s c framework version
558            * @return <code>true</code> if the s c framework version is associated with the s c product version; <code>false</code> otherwise
559            * @throws SystemException if a system exception occurred
560            */
561            public static boolean containsSCFrameworkVersion(long pk,
562                    long scFrameworkVersionPK)
563                    throws com.liferay.portal.kernel.exception.SystemException {
564                    return getPersistence()
565                                       .containsSCFrameworkVersion(pk, scFrameworkVersionPK);
566            }
567    
568            /**
569            * Returns <code>true</code> if the s c product version has any s c framework versions associated with it.
570            *
571            * @param pk the primary key of the s c product version to check for associations with s c framework versions
572            * @return <code>true</code> if the s c product version has any s c framework versions associated with it; <code>false</code> otherwise
573            * @throws SystemException if a system exception occurred
574            */
575            public static boolean containsSCFrameworkVersions(long pk)
576                    throws com.liferay.portal.kernel.exception.SystemException {
577                    return getPersistence().containsSCFrameworkVersions(pk);
578            }
579    
580            /**
581            * 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.
582            *
583            * @param pk the primary key of the s c product version
584            * @param scFrameworkVersionPK the primary key of the s c framework version
585            * @throws SystemException if a system exception occurred
586            */
587            public static void addSCFrameworkVersion(long pk, long scFrameworkVersionPK)
588                    throws com.liferay.portal.kernel.exception.SystemException {
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            * @throws SystemException if a system exception occurred
598            */
599            public static void addSCFrameworkVersion(long pk,
600                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion)
601                    throws com.liferay.portal.kernel.exception.SystemException {
602                    getPersistence().addSCFrameworkVersion(pk, scFrameworkVersion);
603            }
604    
605            /**
606            * 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.
607            *
608            * @param pk the primary key of the s c product version
609            * @param scFrameworkVersionPKs the primary keys of the s c framework versions
610            * @throws SystemException if a system exception occurred
611            */
612            public static void addSCFrameworkVersions(long pk,
613                    long[] scFrameworkVersionPKs)
614                    throws com.liferay.portal.kernel.exception.SystemException {
615                    getPersistence().addSCFrameworkVersions(pk, scFrameworkVersionPKs);
616            }
617    
618            /**
619            * 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.
620            *
621            * @param pk the primary key of the s c product version
622            * @param scFrameworkVersions the s c framework versions
623            * @throws SystemException if a system exception occurred
624            */
625            public static void addSCFrameworkVersions(long pk,
626                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions)
627                    throws com.liferay.portal.kernel.exception.SystemException {
628                    getPersistence().addSCFrameworkVersions(pk, scFrameworkVersions);
629            }
630    
631            /**
632            * 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.
633            *
634            * @param pk the primary key of the s c product version to clear the associated s c framework versions from
635            * @throws SystemException if a system exception occurred
636            */
637            public static void clearSCFrameworkVersions(long pk)
638                    throws com.liferay.portal.kernel.exception.SystemException {
639                    getPersistence().clearSCFrameworkVersions(pk);
640            }
641    
642            /**
643            * 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.
644            *
645            * @param pk the primary key of the s c product version
646            * @param scFrameworkVersionPK the primary key of the s c framework version
647            * @throws SystemException if a system exception occurred
648            */
649            public static void removeSCFrameworkVersion(long pk,
650                    long scFrameworkVersionPK)
651                    throws com.liferay.portal.kernel.exception.SystemException {
652                    getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersionPK);
653            }
654    
655            /**
656            * 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.
657            *
658            * @param pk the primary key of the s c product version
659            * @param scFrameworkVersion the s c framework version
660            * @throws SystemException if a system exception occurred
661            */
662            public static void removeSCFrameworkVersion(long pk,
663                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion)
664                    throws com.liferay.portal.kernel.exception.SystemException {
665                    getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersion);
666            }
667    
668            /**
669            * 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.
670            *
671            * @param pk the primary key of the s c product version
672            * @param scFrameworkVersionPKs the primary keys of the s c framework versions
673            * @throws SystemException if a system exception occurred
674            */
675            public static void removeSCFrameworkVersions(long pk,
676                    long[] scFrameworkVersionPKs)
677                    throws com.liferay.portal.kernel.exception.SystemException {
678                    getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersionPKs);
679            }
680    
681            /**
682            * 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.
683            *
684            * @param pk the primary key of the s c product version
685            * @param scFrameworkVersions the s c framework versions
686            * @throws SystemException if a system exception occurred
687            */
688            public static void removeSCFrameworkVersions(long pk,
689                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions)
690                    throws com.liferay.portal.kernel.exception.SystemException {
691                    getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersions);
692            }
693    
694            /**
695            * 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.
696            *
697            * @param pk the primary key of the s c product version
698            * @param scFrameworkVersionPKs the primary keys of the s c framework versions to be associated with the s c product version
699            * @throws SystemException if a system exception occurred
700            */
701            public static void setSCFrameworkVersions(long pk,
702                    long[] scFrameworkVersionPKs)
703                    throws com.liferay.portal.kernel.exception.SystemException {
704                    getPersistence().setSCFrameworkVersions(pk, scFrameworkVersionPKs);
705            }
706    
707            /**
708            * 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.
709            *
710            * @param pk the primary key of the s c product version
711            * @param scFrameworkVersions the s c framework versions to be associated with the s c product version
712            * @throws SystemException if a system exception occurred
713            */
714            public static void setSCFrameworkVersions(long pk,
715                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions)
716                    throws com.liferay.portal.kernel.exception.SystemException {
717                    getPersistence().setSCFrameworkVersions(pk, scFrameworkVersions);
718            }
719    
720            public static SCProductVersionPersistence getPersistence() {
721                    if (_persistence == null) {
722                            _persistence = (SCProductVersionPersistence)PortalBeanLocatorUtil.locate(SCProductVersionPersistence.class.getName());
723    
724                            ReferenceRegistry.registerReference(SCProductVersionUtil.class,
725                                    "_persistence");
726                    }
727    
728                    return _persistence;
729            }
730    
731            public void setPersistence(SCProductVersionPersistence persistence) {
732                    _persistence = persistence;
733    
734                    ReferenceRegistry.registerReference(SCProductVersionUtil.class,
735                            "_persistence");
736            }
737    
738            private static SCProductVersionPersistence _persistence;
739    }