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            * Returns all the s c product versions where productEntryId = &#63;.
115            *
116            * @param productEntryId the product entry ID
117            * @return the matching s c product versions
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId(
121                    long productEntryId)
122                    throws com.liferay.portal.kernel.exception.SystemException {
123                    return getPersistence().findByProductEntryId(productEntryId);
124            }
125    
126            /**
127            * Returns a range of all the s c product versions where productEntryId = &#63;.
128            *
129            * <p>
130            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
131            * </p>
132            *
133            * @param productEntryId the product entry ID
134            * @param start the lower bound of the range of s c product versions
135            * @param end the upper bound of the range of s c product versions (not inclusive)
136            * @return the range of matching s c product versions
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId(
140                    long productEntryId, int start, int end)
141                    throws com.liferay.portal.kernel.exception.SystemException {
142                    return getPersistence().findByProductEntryId(productEntryId, start, end);
143            }
144    
145            /**
146            * Returns an ordered range of all the s c product versions where productEntryId = &#63;.
147            *
148            * <p>
149            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
150            * </p>
151            *
152            * @param productEntryId the product entry ID
153            * @param start the lower bound of the range of s c product versions
154            * @param end the upper bound of the range of s c product versions (not inclusive)
155            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
156            * @return the ordered range of matching s c product versions
157            * @throws SystemException if a system exception occurred
158            */
159            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId(
160                    long productEntryId, int start, int end,
161                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence()
164                                       .findByProductEntryId(productEntryId, start, end,
165                            orderByComparator);
166            }
167    
168            /**
169            * Returns the first s c product version in the ordered set where productEntryId = &#63;.
170            *
171            * @param productEntryId the product entry ID
172            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
173            * @return the first matching s c product version
174            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found
175            * @throws SystemException if a system exception occurred
176            */
177            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByProductEntryId_First(
178                    long productEntryId,
179                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
180                    throws com.liferay.portal.kernel.exception.SystemException,
181                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
182                    return getPersistence()
183                                       .findByProductEntryId_First(productEntryId, orderByComparator);
184            }
185    
186            /**
187            * Returns the first s c product version in the ordered set where productEntryId = &#63;.
188            *
189            * @param productEntryId the product entry ID
190            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
191            * @return the first matching s c product version, or <code>null</code> if a matching s c product version could not be found
192            * @throws SystemException if a system exception occurred
193            */
194            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByProductEntryId_First(
195                    long productEntryId,
196                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
197                    throws com.liferay.portal.kernel.exception.SystemException {
198                    return getPersistence()
199                                       .fetchByProductEntryId_First(productEntryId,
200                            orderByComparator);
201            }
202    
203            /**
204            * Returns the last s c product version in the ordered set where productEntryId = &#63;.
205            *
206            * @param productEntryId the product entry ID
207            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
208            * @return the last matching s c product version
209            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found
210            * @throws SystemException if a system exception occurred
211            */
212            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByProductEntryId_Last(
213                    long productEntryId,
214                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
215                    throws com.liferay.portal.kernel.exception.SystemException,
216                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
217                    return getPersistence()
218                                       .findByProductEntryId_Last(productEntryId, orderByComparator);
219            }
220    
221            /**
222            * Returns the last s c product version in the ordered set where productEntryId = &#63;.
223            *
224            * @param productEntryId the product entry ID
225            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
226            * @return the last matching s c product version, or <code>null</code> if a matching s c product version could not be found
227            * @throws SystemException if a system exception occurred
228            */
229            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByProductEntryId_Last(
230                    long productEntryId,
231                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
232                    throws com.liferay.portal.kernel.exception.SystemException {
233                    return getPersistence()
234                                       .fetchByProductEntryId_Last(productEntryId, orderByComparator);
235            }
236    
237            /**
238            * Returns the s c product versions before and after the current s c product version in the ordered set where productEntryId = &#63;.
239            *
240            * @param productVersionId the primary key of the current s c product version
241            * @param productEntryId the product entry ID
242            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
243            * @return the previous, current, and next s c product version
244            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found
245            * @throws SystemException if a system exception occurred
246            */
247            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion[] findByProductEntryId_PrevAndNext(
248                    long productVersionId, long productEntryId,
249                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
250                    throws com.liferay.portal.kernel.exception.SystemException,
251                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
252                    return getPersistence()
253                                       .findByProductEntryId_PrevAndNext(productVersionId,
254                            productEntryId, orderByComparator);
255            }
256    
257            /**
258            * Removes all the s c product versions where productEntryId = &#63; from the database.
259            *
260            * @param productEntryId the product entry ID
261            * @throws SystemException if a system exception occurred
262            */
263            public static void removeByProductEntryId(long productEntryId)
264                    throws com.liferay.portal.kernel.exception.SystemException {
265                    getPersistence().removeByProductEntryId(productEntryId);
266            }
267    
268            /**
269            * Returns the number of s c product versions where productEntryId = &#63;.
270            *
271            * @param productEntryId the product entry ID
272            * @return the number of matching s c product versions
273            * @throws SystemException if a system exception occurred
274            */
275            public static int countByProductEntryId(long productEntryId)
276                    throws com.liferay.portal.kernel.exception.SystemException {
277                    return getPersistence().countByProductEntryId(productEntryId);
278            }
279    
280            /**
281            * Returns the s c product version where directDownloadURL = &#63; or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchProductVersionException} if it could not be found.
282            *
283            * @param directDownloadURL the direct download u r l
284            * @return the matching s c product version
285            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found
286            * @throws SystemException if a system exception occurred
287            */
288            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByDirectDownloadURL(
289                    java.lang.String directDownloadURL)
290                    throws com.liferay.portal.kernel.exception.SystemException,
291                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
292                    return getPersistence().findByDirectDownloadURL(directDownloadURL);
293            }
294    
295            /**
296            * Returns the s c product version where directDownloadURL = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
297            *
298            * @param directDownloadURL the direct download u r l
299            * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found
300            * @throws SystemException if a system exception occurred
301            */
302            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL(
303                    java.lang.String directDownloadURL)
304                    throws com.liferay.portal.kernel.exception.SystemException {
305                    return getPersistence().fetchByDirectDownloadURL(directDownloadURL);
306            }
307    
308            /**
309            * 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.
310            *
311            * @param directDownloadURL the direct download u r l
312            * @param retrieveFromCache whether to use the finder cache
313            * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found
314            * @throws SystemException if a system exception occurred
315            */
316            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL(
317                    java.lang.String directDownloadURL, boolean retrieveFromCache)
318                    throws com.liferay.portal.kernel.exception.SystemException {
319                    return getPersistence()
320                                       .fetchByDirectDownloadURL(directDownloadURL,
321                            retrieveFromCache);
322            }
323    
324            /**
325            * Removes the s c product version where directDownloadURL = &#63; from the database.
326            *
327            * @param directDownloadURL the direct download u r l
328            * @return the s c product version that was removed
329            * @throws SystemException if a system exception occurred
330            */
331            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion removeByDirectDownloadURL(
332                    java.lang.String directDownloadURL)
333                    throws com.liferay.portal.kernel.exception.SystemException,
334                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
335                    return getPersistence().removeByDirectDownloadURL(directDownloadURL);
336            }
337    
338            /**
339            * Returns the number of s c product versions where directDownloadURL = &#63;.
340            *
341            * @param directDownloadURL the direct download u r l
342            * @return the number of matching s c product versions
343            * @throws SystemException if a system exception occurred
344            */
345            public static int countByDirectDownloadURL(
346                    java.lang.String directDownloadURL)
347                    throws com.liferay.portal.kernel.exception.SystemException {
348                    return getPersistence().countByDirectDownloadURL(directDownloadURL);
349            }
350    
351            /**
352            * Caches the s c product version in the entity cache if it is enabled.
353            *
354            * @param scProductVersion the s c product version
355            */
356            public static void cacheResult(
357                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) {
358                    getPersistence().cacheResult(scProductVersion);
359            }
360    
361            /**
362            * Caches the s c product versions in the entity cache if it is enabled.
363            *
364            * @param scProductVersions the s c product versions
365            */
366            public static void cacheResult(
367                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) {
368                    getPersistence().cacheResult(scProductVersions);
369            }
370    
371            /**
372            * Creates a new s c product version with the primary key. Does not add the s c product version to the database.
373            *
374            * @param productVersionId the primary key for the new s c product version
375            * @return the new s c product version
376            */
377            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion create(
378                    long productVersionId) {
379                    return getPersistence().create(productVersionId);
380            }
381    
382            /**
383            * Removes the s c product version with the primary key from the database. Also notifies the appropriate model listeners.
384            *
385            * @param productVersionId the primary key of the s c product version
386            * @return the s c product version that was removed
387            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found
388            * @throws SystemException if a system exception occurred
389            */
390            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion remove(
391                    long productVersionId)
392                    throws com.liferay.portal.kernel.exception.SystemException,
393                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
394                    return getPersistence().remove(productVersionId);
395            }
396    
397            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion updateImpl(
398                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
399                    throws com.liferay.portal.kernel.exception.SystemException {
400                    return getPersistence().updateImpl(scProductVersion);
401            }
402    
403            /**
404            * 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.
405            *
406            * @param productVersionId the primary key of the s c product version
407            * @return the s c product version
408            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found
409            * @throws SystemException if a system exception occurred
410            */
411            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByPrimaryKey(
412                    long productVersionId)
413                    throws com.liferay.portal.kernel.exception.SystemException,
414                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
415                    return getPersistence().findByPrimaryKey(productVersionId);
416            }
417    
418            /**
419            * Returns the s c product version with the primary key or returns <code>null</code> if it could not be found.
420            *
421            * @param productVersionId the primary key of the s c product version
422            * @return the s c product version, or <code>null</code> if a s c product version with the primary key could not be found
423            * @throws SystemException if a system exception occurred
424            */
425            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByPrimaryKey(
426                    long productVersionId)
427                    throws com.liferay.portal.kernel.exception.SystemException {
428                    return getPersistence().fetchByPrimaryKey(productVersionId);
429            }
430    
431            /**
432            * Returns all the s c product versions.
433            *
434            * @return the s c product versions
435            * @throws SystemException if a system exception occurred
436            */
437            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll()
438                    throws com.liferay.portal.kernel.exception.SystemException {
439                    return getPersistence().findAll();
440            }
441    
442            /**
443            * Returns a range of all the s c product versions.
444            *
445            * <p>
446            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
447            * </p>
448            *
449            * @param start the lower bound of the range of s c product versions
450            * @param end the upper bound of the range of s c product versions (not inclusive)
451            * @return the range of s c product versions
452            * @throws SystemException if a system exception occurred
453            */
454            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll(
455                    int start, int end)
456                    throws com.liferay.portal.kernel.exception.SystemException {
457                    return getPersistence().findAll(start, end);
458            }
459    
460            /**
461            * Returns an ordered range of all the s c product versions.
462            *
463            * <p>
464            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
465            * </p>
466            *
467            * @param start the lower bound of the range of s c product versions
468            * @param end the upper bound of the range of s c product versions (not inclusive)
469            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
470            * @return the ordered range of s c product versions
471            * @throws SystemException if a system exception occurred
472            */
473            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll(
474                    int start, int end,
475                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
476                    throws com.liferay.portal.kernel.exception.SystemException {
477                    return getPersistence().findAll(start, end, orderByComparator);
478            }
479    
480            /**
481            * Removes all the s c product versions from the database.
482            *
483            * @throws SystemException if a system exception occurred
484            */
485            public static void removeAll()
486                    throws com.liferay.portal.kernel.exception.SystemException {
487                    getPersistence().removeAll();
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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
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    }