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