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 to cache
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 to cache
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 to remove
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            * Finds 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 to find
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            * Finds 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 to find
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            * Finds all the s c product versions where productEntryId = &#63;.
204            *
205            * @param productEntryId the product entry ID to search with
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            * Finds 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 to search with
223            * @param start the lower bound of the range of s c product versions to return
224            * @param end the upper bound of the range of s c product versions to return (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            * Finds 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 to search with
242            * @param start the lower bound of the range of s c product versions to return
243            * @param end the upper bound of the range of s c product versions to return (not inclusive)
244            * @param orderByComparator the comparator to order the results by
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            * Finds 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 to search with
265            * @param orderByComparator the comparator to order the set by
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            * Finds 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 to search with
287            * @param orderByComparator the comparator to order the set by
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            * Finds 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 to search with
310            * @param orderByComparator the comparator to order the set by
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            * Finds 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 to search with
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            * Finds 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 to search with
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            * Finds 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 to search with
357            * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found
358            * @throws SystemException if a system exception occurred
359            */
360            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL(
361                    java.lang.String directDownloadURL, boolean retrieveFromCache)
362                    throws com.liferay.portal.kernel.exception.SystemException {
363                    return getPersistence()
364                                       .fetchByDirectDownloadURL(directDownloadURL,
365                            retrieveFromCache);
366            }
367    
368            /**
369            * Finds all the s c product versions.
370            *
371            * @return the s c product versions
372            * @throws SystemException if a system exception occurred
373            */
374            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll()
375                    throws com.liferay.portal.kernel.exception.SystemException {
376                    return getPersistence().findAll();
377            }
378    
379            /**
380            * Finds a range of all the s c product versions.
381            *
382            * <p>
383            * 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.
384            * </p>
385            *
386            * @param start the lower bound of the range of s c product versions to return
387            * @param end the upper bound of the range of s c product versions to return (not inclusive)
388            * @return the range of s c product versions
389            * @throws SystemException if a system exception occurred
390            */
391            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll(
392                    int start, int end)
393                    throws com.liferay.portal.kernel.exception.SystemException {
394                    return getPersistence().findAll(start, end);
395            }
396    
397            /**
398            * Finds an ordered range of all the s c product versions.
399            *
400            * <p>
401            * 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.
402            * </p>
403            *
404            * @param start the lower bound of the range of s c product versions to return
405            * @param end the upper bound of the range of s c product versions to return (not inclusive)
406            * @param orderByComparator the comparator to order the results by
407            * @return the ordered range of s c product versions
408            * @throws SystemException if a system exception occurred
409            */
410            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll(
411                    int start, int end,
412                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
413                    throws com.liferay.portal.kernel.exception.SystemException {
414                    return getPersistence().findAll(start, end, orderByComparator);
415            }
416    
417            /**
418            * Removes all the s c product versions where productEntryId = &#63; from the database.
419            *
420            * @param productEntryId the product entry ID to search with
421            * @throws SystemException if a system exception occurred
422            */
423            public static void removeByProductEntryId(long productEntryId)
424                    throws com.liferay.portal.kernel.exception.SystemException {
425                    getPersistence().removeByProductEntryId(productEntryId);
426            }
427    
428            /**
429            * Removes the s c product version where directDownloadURL = &#63; from the database.
430            *
431            * @param directDownloadURL the direct download u r l to search with
432            * @throws SystemException if a system exception occurred
433            */
434            public static void removeByDirectDownloadURL(
435                    java.lang.String directDownloadURL)
436                    throws com.liferay.portal.kernel.exception.SystemException,
437                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
438                    getPersistence().removeByDirectDownloadURL(directDownloadURL);
439            }
440    
441            /**
442            * Removes all the s c product versions from the database.
443            *
444            * @throws SystemException if a system exception occurred
445            */
446            public static void removeAll()
447                    throws com.liferay.portal.kernel.exception.SystemException {
448                    getPersistence().removeAll();
449            }
450    
451            /**
452            * Counts all the s c product versions where productEntryId = &#63;.
453            *
454            * @param productEntryId the product entry ID to search with
455            * @return the number of matching s c product versions
456            * @throws SystemException if a system exception occurred
457            */
458            public static int countByProductEntryId(long productEntryId)
459                    throws com.liferay.portal.kernel.exception.SystemException {
460                    return getPersistence().countByProductEntryId(productEntryId);
461            }
462    
463            /**
464            * Counts all the s c product versions where directDownloadURL = &#63;.
465            *
466            * @param directDownloadURL the direct download u r l to search with
467            * @return the number of matching s c product versions
468            * @throws SystemException if a system exception occurred
469            */
470            public static int countByDirectDownloadURL(
471                    java.lang.String directDownloadURL)
472                    throws com.liferay.portal.kernel.exception.SystemException {
473                    return getPersistence().countByDirectDownloadURL(directDownloadURL);
474            }
475    
476            /**
477            * Counts all the s c product versions.
478            *
479            * @return the number of s c product versions
480            * @throws SystemException if a system exception occurred
481            */
482            public static int countAll()
483                    throws com.liferay.portal.kernel.exception.SystemException {
484                    return getPersistence().countAll();
485            }
486    
487            /**
488            * Gets all the s c framework versions associated with the s c product version.
489            *
490            * @param pk the primary key of the s c product version to get the associated s c framework versions for
491            * @return the s c framework versions associated with the s c product version
492            * @throws SystemException if a system exception occurred
493            */
494            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
495                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
496                    return getPersistence().getSCFrameworkVersions(pk);
497            }
498    
499            /**
500            * Gets a range of all the s c framework versions associated with the s c product version.
501            *
502            * <p>
503            * 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.
504            * </p>
505            *
506            * @param pk the primary key of the s c product version to get the associated s c framework versions for
507            * @param start the lower bound of the range of s c product versions to return
508            * @param end the upper bound of the range of s c product versions to return (not inclusive)
509            * @return the range of s c framework versions associated with the s c product version
510            * @throws SystemException if a system exception occurred
511            */
512            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
513                    long pk, int start, int end)
514                    throws com.liferay.portal.kernel.exception.SystemException {
515                    return getPersistence().getSCFrameworkVersions(pk, start, end);
516            }
517    
518            /**
519            * Gets an ordered range of all the s c framework versions associated with the s c product version.
520            *
521            * <p>
522            * 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.
523            * </p>
524            *
525            * @param pk the primary key of the s c product version to get the associated s c framework versions for
526            * @param start the lower bound of the range of s c product versions to return
527            * @param end the upper bound of the range of s c product versions to return (not inclusive)
528            * @param orderByComparator the comparator to order the results by
529            * @return the ordered range of s c framework versions associated with the s c product version
530            * @throws SystemException if a system exception occurred
531            */
532            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
533                    long pk, int start, int end,
534                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
535                    throws com.liferay.portal.kernel.exception.SystemException {
536                    return getPersistence()
537                                       .getSCFrameworkVersions(pk, start, end, orderByComparator);
538            }
539    
540            /**
541            * Gets the number of s c framework versions associated with the s c product version.
542            *
543            * @param pk the primary key of the s c product version to get the number of associated s c framework versions for
544            * @return the number of s c framework versions associated with the s c product version
545            * @throws SystemException if a system exception occurred
546            */
547            public static int getSCFrameworkVersionsSize(long pk)
548                    throws com.liferay.portal.kernel.exception.SystemException {
549                    return getPersistence().getSCFrameworkVersionsSize(pk);
550            }
551    
552            /**
553            * Determines if the s c framework version is associated with the s c product version.
554            *
555            * @param pk the primary key of the s c product version
556            * @param scFrameworkVersionPK the primary key of the s c framework version
557            * @return <code>true</code> if the s c framework version is associated with the s c product version; <code>false</code> otherwise
558            * @throws SystemException if a system exception occurred
559            */
560            public static boolean containsSCFrameworkVersion(long pk,
561                    long scFrameworkVersionPK)
562                    throws com.liferay.portal.kernel.exception.SystemException {
563                    return getPersistence()
564                                       .containsSCFrameworkVersion(pk, scFrameworkVersionPK);
565            }
566    
567            /**
568            * Determines if the s c product version has any s c framework versions associated with it.
569            *
570            * @param pk the primary key of the s c product version to check for associations with s c framework versions
571            * @return <code>true</code> if the s c product version has any s c framework versions associated with it; <code>false</code> otherwise
572            * @throws SystemException if a system exception occurred
573            */
574            public static boolean containsSCFrameworkVersions(long pk)
575                    throws com.liferay.portal.kernel.exception.SystemException {
576                    return getPersistence().containsSCFrameworkVersions(pk);
577            }
578    
579            /**
580            * 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.
581            *
582            * @param pk the primary key of the s c product version
583            * @param scFrameworkVersionPK the primary key of the s c framework version
584            * @throws SystemException if a system exception occurred
585            */
586            public static void addSCFrameworkVersion(long pk, long scFrameworkVersionPK)
587                    throws com.liferay.portal.kernel.exception.SystemException {
588                    getPersistence().addSCFrameworkVersion(pk, scFrameworkVersionPK);
589            }
590    
591            /**
592            * 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.
593            *
594            * @param pk the primary key of the s c product version
595            * @param scFrameworkVersion the s c framework version
596            * @throws SystemException if a system exception occurred
597            */
598            public static void addSCFrameworkVersion(long pk,
599                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion)
600                    throws com.liferay.portal.kernel.exception.SystemException {
601                    getPersistence().addSCFrameworkVersion(pk, scFrameworkVersion);
602            }
603    
604            /**
605            * 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.
606            *
607            * @param pk the primary key of the s c product version
608            * @param scFrameworkVersionPKs the primary keys of the s c framework versions
609            * @throws SystemException if a system exception occurred
610            */
611            public static void addSCFrameworkVersions(long pk,
612                    long[] scFrameworkVersionPKs)
613                    throws com.liferay.portal.kernel.exception.SystemException {
614                    getPersistence().addSCFrameworkVersions(pk, scFrameworkVersionPKs);
615            }
616    
617            /**
618            * 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.
619            *
620            * @param pk the primary key of the s c product version
621            * @param scFrameworkVersions the s c framework versions
622            * @throws SystemException if a system exception occurred
623            */
624            public static void addSCFrameworkVersions(long pk,
625                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions)
626                    throws com.liferay.portal.kernel.exception.SystemException {
627                    getPersistence().addSCFrameworkVersions(pk, scFrameworkVersions);
628            }
629    
630            /**
631            * 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.
632            *
633            * @param pk the primary key of the s c product version to clear the associated s c framework versions from
634            * @throws SystemException if a system exception occurred
635            */
636            public static void clearSCFrameworkVersions(long pk)
637                    throws com.liferay.portal.kernel.exception.SystemException {
638                    getPersistence().clearSCFrameworkVersions(pk);
639            }
640    
641            /**
642            * 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.
643            *
644            * @param pk the primary key of the s c product version
645            * @param scFrameworkVersionPK the primary key of the s c framework version
646            * @throws SystemException if a system exception occurred
647            */
648            public static void removeSCFrameworkVersion(long pk,
649                    long scFrameworkVersionPK)
650                    throws com.liferay.portal.kernel.exception.SystemException {
651                    getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersionPK);
652            }
653    
654            /**
655            * 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.
656            *
657            * @param pk the primary key of the s c product version
658            * @param scFrameworkVersion the s c framework version
659            * @throws SystemException if a system exception occurred
660            */
661            public static void removeSCFrameworkVersion(long pk,
662                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion)
663                    throws com.liferay.portal.kernel.exception.SystemException {
664                    getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersion);
665            }
666    
667            /**
668            * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
669            *
670            * @param pk the primary key of the s c product version
671            * @param scFrameworkVersionPKs the primary keys of the s c framework versions
672            * @throws SystemException if a system exception occurred
673            */
674            public static void removeSCFrameworkVersions(long pk,
675                    long[] scFrameworkVersionPKs)
676                    throws com.liferay.portal.kernel.exception.SystemException {
677                    getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersionPKs);
678            }
679    
680            /**
681            * 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.
682            *
683            * @param pk the primary key of the s c product version
684            * @param scFrameworkVersions the s c framework versions
685            * @throws SystemException if a system exception occurred
686            */
687            public static void removeSCFrameworkVersions(long pk,
688                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions)
689                    throws com.liferay.portal.kernel.exception.SystemException {
690                    getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersions);
691            }
692    
693            /**
694            * 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.
695            *
696            * @param pk the primary key of the s c product version to set the associations for
697            * @param scFrameworkVersionPKs the primary keys of the s c framework versions to be associated with the s c product version
698            * @throws SystemException if a system exception occurred
699            */
700            public static void setSCFrameworkVersions(long pk,
701                    long[] scFrameworkVersionPKs)
702                    throws com.liferay.portal.kernel.exception.SystemException {
703                    getPersistence().setSCFrameworkVersions(pk, scFrameworkVersionPKs);
704            }
705    
706            /**
707            * 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.
708            *
709            * @param pk the primary key of the s c product version to set the associations for
710            * @param scFrameworkVersions the s c framework versions to be associated with the s c product version
711            * @throws SystemException if a system exception occurred
712            */
713            public static void setSCFrameworkVersions(long pk,
714                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions)
715                    throws com.liferay.portal.kernel.exception.SystemException {
716                    getPersistence().setSCFrameworkVersions(pk, scFrameworkVersions);
717            }
718    
719            public static SCProductVersionPersistence getPersistence() {
720                    if (_persistence == null) {
721                            _persistence = (SCProductVersionPersistence)PortalBeanLocatorUtil.locate(SCProductVersionPersistence.class.getName());
722    
723                            ReferenceRegistry.registerReference(SCProductVersionUtil.class,
724                                    "_persistence");
725                    }
726    
727                    return _persistence;
728            }
729    
730            public void setPersistence(SCProductVersionPersistence persistence) {
731                    _persistence = persistence;
732    
733                    ReferenceRegistry.registerReference(SCProductVersionUtil.class,
734                            "_persistence");
735            }
736    
737            private static SCProductVersionPersistence _persistence;
738    }