001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.softwarecatalog.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.service.ServiceContext;
022    
023    import com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the s c framework version service. This utility wraps {@link SCFrameworkVersionPersistenceImpl} 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.
029     *
030     * <p>
031     * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
032     * </p>
033     *
034     * <p>
035     * Caching information and settings can be found in <code>portal.properties</code>
036     * </p>
037     *
038     * @author Brian Wing Shun Chan
039     * @see SCFrameworkVersionPersistence
040     * @see SCFrameworkVersionPersistenceImpl
041     * @generated
042     */
043    public class SCFrameworkVersionUtil {
044            /**
045             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
046             */
047            public static void clearCache() {
048                    getPersistence().clearCache();
049            }
050    
051            /**
052             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
053             */
054            public static void clearCache(SCFrameworkVersion scFrameworkVersion) {
055                    getPersistence().clearCache(scFrameworkVersion);
056            }
057    
058            /**
059             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
060             */
061            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
062                    throws SystemException {
063                    return getPersistence().countWithDynamicQuery(dynamicQuery);
064            }
065    
066            /**
067             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
068             */
069            public static List<SCFrameworkVersion> findWithDynamicQuery(
070                    DynamicQuery dynamicQuery) throws SystemException {
071                    return getPersistence().findWithDynamicQuery(dynamicQuery);
072            }
073    
074            /**
075             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
076             */
077            public static List<SCFrameworkVersion> findWithDynamicQuery(
078                    DynamicQuery dynamicQuery, int start, int end)
079                    throws SystemException {
080                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
081            }
082    
083            /**
084             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
085             */
086            public static List<SCFrameworkVersion> findWithDynamicQuery(
087                    DynamicQuery dynamicQuery, int start, int end,
088                    OrderByComparator orderByComparator) throws SystemException {
089                    return getPersistence()
090                                       .findWithDynamicQuery(dynamicQuery, start, end,
091                            orderByComparator);
092            }
093    
094            /**
095             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
096             */
097            public static SCFrameworkVersion remove(
098                    SCFrameworkVersion scFrameworkVersion) throws SystemException {
099                    return getPersistence().remove(scFrameworkVersion);
100            }
101    
102            /**
103             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
104             */
105            public static SCFrameworkVersion update(
106                    SCFrameworkVersion scFrameworkVersion, boolean merge)
107                    throws SystemException {
108                    return getPersistence().update(scFrameworkVersion, merge);
109            }
110    
111            /**
112             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
113             */
114            public static SCFrameworkVersion update(
115                    SCFrameworkVersion scFrameworkVersion, boolean merge,
116                    ServiceContext serviceContext) throws SystemException {
117                    return getPersistence().update(scFrameworkVersion, merge, serviceContext);
118            }
119    
120            /**
121            * Caches the s c framework version in the entity cache if it is enabled.
122            *
123            * @param scFrameworkVersion the s c framework version to cache
124            */
125            public static void cacheResult(
126                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) {
127                    getPersistence().cacheResult(scFrameworkVersion);
128            }
129    
130            /**
131            * Caches the s c framework versions in the entity cache if it is enabled.
132            *
133            * @param scFrameworkVersions the s c framework versions to cache
134            */
135            public static void cacheResult(
136                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) {
137                    getPersistence().cacheResult(scFrameworkVersions);
138            }
139    
140            /**
141            * Creates a new s c framework version with the primary key. Does not add the s c framework version to the database.
142            *
143            * @param frameworkVersionId the primary key for the new s c framework version
144            * @return the new s c framework version
145            */
146            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion create(
147                    long frameworkVersionId) {
148                    return getPersistence().create(frameworkVersionId);
149            }
150    
151            /**
152            * Removes the s c framework version with the primary key from the database. Also notifies the appropriate model listeners.
153            *
154            * @param frameworkVersionId the primary key of the s c framework version to remove
155            * @return the s c framework version that was removed
156            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
157            * @throws SystemException if a system exception occurred
158            */
159            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion remove(
160                    long frameworkVersionId)
161                    throws com.liferay.portal.kernel.exception.SystemException,
162                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
163                    return getPersistence().remove(frameworkVersionId);
164            }
165    
166            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion updateImpl(
167                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion,
168                    boolean merge)
169                    throws com.liferay.portal.kernel.exception.SystemException {
170                    return getPersistence().updateImpl(scFrameworkVersion, merge);
171            }
172    
173            /**
174            * Finds the s c framework version with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException} if it could not be found.
175            *
176            * @param frameworkVersionId the primary key of the s c framework version to find
177            * @return the s c framework version
178            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
179            * @throws SystemException if a system exception occurred
180            */
181            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByPrimaryKey(
182                    long frameworkVersionId)
183                    throws com.liferay.portal.kernel.exception.SystemException,
184                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
185                    return getPersistence().findByPrimaryKey(frameworkVersionId);
186            }
187    
188            /**
189            * Finds the s c framework version with the primary key or returns <code>null</code> if it could not be found.
190            *
191            * @param frameworkVersionId the primary key of the s c framework version to find
192            * @return the s c framework version, or <code>null</code> if a s c framework version with the primary key could not be found
193            * @throws SystemException if a system exception occurred
194            */
195            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion fetchByPrimaryKey(
196                    long frameworkVersionId)
197                    throws com.liferay.portal.kernel.exception.SystemException {
198                    return getPersistence().fetchByPrimaryKey(frameworkVersionId);
199            }
200    
201            /**
202            * Finds all the s c framework versions where groupId = &#63;.
203            *
204            * @param groupId the group id to search with
205            * @return the matching s c framework versions
206            * @throws SystemException if a system exception occurred
207            */
208            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByGroupId(
209                    long groupId)
210                    throws com.liferay.portal.kernel.exception.SystemException {
211                    return getPersistence().findByGroupId(groupId);
212            }
213    
214            /**
215            * Finds a range of all the s c framework versions where groupId = &#63;.
216            *
217            * <p>
218            * 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.
219            * </p>
220            *
221            * @param groupId the group id to search with
222            * @param start the lower bound of the range of s c framework versions to return
223            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
224            * @return the range of matching s c framework versions
225            * @throws SystemException if a system exception occurred
226            */
227            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByGroupId(
228                    long groupId, int start, int end)
229                    throws com.liferay.portal.kernel.exception.SystemException {
230                    return getPersistence().findByGroupId(groupId, start, end);
231            }
232    
233            /**
234            * Finds an ordered range of all the s c framework versions where groupId = &#63;.
235            *
236            * <p>
237            * 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.
238            * </p>
239            *
240            * @param groupId the group id to search with
241            * @param start the lower bound of the range of s c framework versions to return
242            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
243            * @param orderByComparator the comparator to order the results by
244            * @return the ordered range of matching s c framework versions
245            * @throws SystemException if a system exception occurred
246            */
247            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByGroupId(
248                    long groupId, int start, int end,
249                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
250                    throws com.liferay.portal.kernel.exception.SystemException {
251                    return getPersistence()
252                                       .findByGroupId(groupId, start, end, orderByComparator);
253            }
254    
255            /**
256            * Finds the first s c framework version in the ordered set where groupId = &#63;.
257            *
258            * <p>
259            * 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.
260            * </p>
261            *
262            * @param groupId the group id to search with
263            * @param orderByComparator the comparator to order the set by
264            * @return the first matching s c framework version
265            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found
266            * @throws SystemException if a system exception occurred
267            */
268            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByGroupId_First(
269                    long groupId,
270                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
271                    throws com.liferay.portal.kernel.exception.SystemException,
272                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
273                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
274            }
275    
276            /**
277            * Finds the last s c framework version in the ordered set where groupId = &#63;.
278            *
279            * <p>
280            * 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.
281            * </p>
282            *
283            * @param groupId the group id to search with
284            * @param orderByComparator the comparator to order the set by
285            * @return the last matching s c framework version
286            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found
287            * @throws SystemException if a system exception occurred
288            */
289            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByGroupId_Last(
290                    long groupId,
291                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
292                    throws com.liferay.portal.kernel.exception.SystemException,
293                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
294                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
295            }
296    
297            /**
298            * Finds the s c framework versions before and after the current s c framework version in the ordered set where groupId = &#63;.
299            *
300            * <p>
301            * 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.
302            * </p>
303            *
304            * @param frameworkVersionId the primary key of the current s c framework version
305            * @param groupId the group id to search with
306            * @param orderByComparator the comparator to order the set by
307            * @return the previous, current, and next s c framework version
308            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
309            * @throws SystemException if a system exception occurred
310            */
311            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByGroupId_PrevAndNext(
312                    long frameworkVersionId, long groupId,
313                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
314                    throws com.liferay.portal.kernel.exception.SystemException,
315                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
316                    return getPersistence()
317                                       .findByGroupId_PrevAndNext(frameworkVersionId, groupId,
318                            orderByComparator);
319            }
320    
321            /**
322            * Filters by the user's permissions and finds all the s c framework versions where groupId = &#63;.
323            *
324            * @param groupId the group id to search with
325            * @return the matching s c framework versions that the user has permission to view
326            * @throws SystemException if a system exception occurred
327            */
328            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByGroupId(
329                    long groupId)
330                    throws com.liferay.portal.kernel.exception.SystemException {
331                    return getPersistence().filterFindByGroupId(groupId);
332            }
333    
334            /**
335            * Filters by the user's permissions and finds a range of all the s c framework versions where groupId = &#63;.
336            *
337            * <p>
338            * 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.
339            * </p>
340            *
341            * @param groupId the group id to search with
342            * @param start the lower bound of the range of s c framework versions to return
343            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
344            * @return the range of matching s c framework versions that the user has permission to view
345            * @throws SystemException if a system exception occurred
346            */
347            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByGroupId(
348                    long groupId, int start, int end)
349                    throws com.liferay.portal.kernel.exception.SystemException {
350                    return getPersistence().filterFindByGroupId(groupId, start, end);
351            }
352    
353            /**
354            * Filters by the user's permissions and finds an ordered range of all the s c framework versions where groupId = &#63;.
355            *
356            * <p>
357            * 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.
358            * </p>
359            *
360            * @param groupId the group id to search with
361            * @param start the lower bound of the range of s c framework versions to return
362            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
363            * @param orderByComparator the comparator to order the results by
364            * @return the ordered range of matching s c framework versions that the user has permission to view
365            * @throws SystemException if a system exception occurred
366            */
367            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByGroupId(
368                    long groupId, int start, int end,
369                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
370                    throws com.liferay.portal.kernel.exception.SystemException {
371                    return getPersistence()
372                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
373            }
374    
375            /**
376            * Finds all the s c framework versions where companyId = &#63;.
377            *
378            * @param companyId the company id to search with
379            * @return the matching s c framework versions
380            * @throws SystemException if a system exception occurred
381            */
382            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId(
383                    long companyId)
384                    throws com.liferay.portal.kernel.exception.SystemException {
385                    return getPersistence().findByCompanyId(companyId);
386            }
387    
388            /**
389            * Finds a range of all the s c framework versions where companyId = &#63;.
390            *
391            * <p>
392            * 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.
393            * </p>
394            *
395            * @param companyId the company id to search with
396            * @param start the lower bound of the range of s c framework versions to return
397            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
398            * @return the range of matching s c framework versions
399            * @throws SystemException if a system exception occurred
400            */
401            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId(
402                    long companyId, int start, int end)
403                    throws com.liferay.portal.kernel.exception.SystemException {
404                    return getPersistence().findByCompanyId(companyId, start, end);
405            }
406    
407            /**
408            * Finds an ordered range of all the s c framework versions where companyId = &#63;.
409            *
410            * <p>
411            * 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.
412            * </p>
413            *
414            * @param companyId the company id to search with
415            * @param start the lower bound of the range of s c framework versions to return
416            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
417            * @param orderByComparator the comparator to order the results by
418            * @return the ordered range of matching s c framework versions
419            * @throws SystemException if a system exception occurred
420            */
421            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId(
422                    long companyId, int start, int end,
423                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
424                    throws com.liferay.portal.kernel.exception.SystemException {
425                    return getPersistence()
426                                       .findByCompanyId(companyId, start, end, orderByComparator);
427            }
428    
429            /**
430            * Finds the first s c framework version in the ordered set where companyId = &#63;.
431            *
432            * <p>
433            * 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.
434            * </p>
435            *
436            * @param companyId the company id to search with
437            * @param orderByComparator the comparator to order the set by
438            * @return the first matching s c framework version
439            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found
440            * @throws SystemException if a system exception occurred
441            */
442            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByCompanyId_First(
443                    long companyId,
444                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
445                    throws com.liferay.portal.kernel.exception.SystemException,
446                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
447                    return getPersistence()
448                                       .findByCompanyId_First(companyId, orderByComparator);
449            }
450    
451            /**
452            * Finds the last s c framework version in the ordered set where companyId = &#63;.
453            *
454            * <p>
455            * 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.
456            * </p>
457            *
458            * @param companyId the company id to search with
459            * @param orderByComparator the comparator to order the set by
460            * @return the last matching s c framework version
461            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found
462            * @throws SystemException if a system exception occurred
463            */
464            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByCompanyId_Last(
465                    long companyId,
466                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
467                    throws com.liferay.portal.kernel.exception.SystemException,
468                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
469                    return getPersistence()
470                                       .findByCompanyId_Last(companyId, orderByComparator);
471            }
472    
473            /**
474            * Finds the s c framework versions before and after the current s c framework version in the ordered set where companyId = &#63;.
475            *
476            * <p>
477            * 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.
478            * </p>
479            *
480            * @param frameworkVersionId the primary key of the current s c framework version
481            * @param companyId the company id to search with
482            * @param orderByComparator the comparator to order the set by
483            * @return the previous, current, and next s c framework version
484            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
485            * @throws SystemException if a system exception occurred
486            */
487            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByCompanyId_PrevAndNext(
488                    long frameworkVersionId, long companyId,
489                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
490                    throws com.liferay.portal.kernel.exception.SystemException,
491                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
492                    return getPersistence()
493                                       .findByCompanyId_PrevAndNext(frameworkVersionId, companyId,
494                            orderByComparator);
495            }
496    
497            /**
498            * Finds all the s c framework versions where groupId = &#63; and active = &#63;.
499            *
500            * @param groupId the group id to search with
501            * @param active the active to search with
502            * @return the matching s c framework versions
503            * @throws SystemException if a system exception occurred
504            */
505            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A(
506                    long groupId, boolean active)
507                    throws com.liferay.portal.kernel.exception.SystemException {
508                    return getPersistence().findByG_A(groupId, active);
509            }
510    
511            /**
512            * Finds a range of all the s c framework versions where groupId = &#63; and active = &#63;.
513            *
514            * <p>
515            * 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.
516            * </p>
517            *
518            * @param groupId the group id to search with
519            * @param active the active to search with
520            * @param start the lower bound of the range of s c framework versions to return
521            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
522            * @return the range of matching s c framework versions
523            * @throws SystemException if a system exception occurred
524            */
525            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A(
526                    long groupId, boolean active, int start, int end)
527                    throws com.liferay.portal.kernel.exception.SystemException {
528                    return getPersistence().findByG_A(groupId, active, start, end);
529            }
530    
531            /**
532            * Finds an ordered range of all the s c framework versions where groupId = &#63; and active = &#63;.
533            *
534            * <p>
535            * 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.
536            * </p>
537            *
538            * @param groupId the group id to search with
539            * @param active the active to search with
540            * @param start the lower bound of the range of s c framework versions to return
541            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
542            * @param orderByComparator the comparator to order the results by
543            * @return the ordered range of matching s c framework versions
544            * @throws SystemException if a system exception occurred
545            */
546            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A(
547                    long groupId, boolean active, int start, int end,
548                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
549                    throws com.liferay.portal.kernel.exception.SystemException {
550                    return getPersistence()
551                                       .findByG_A(groupId, active, start, end, orderByComparator);
552            }
553    
554            /**
555            * Finds the first s c framework version in the ordered set where groupId = &#63; and active = &#63;.
556            *
557            * <p>
558            * 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.
559            * </p>
560            *
561            * @param groupId the group id to search with
562            * @param active the active to search with
563            * @param orderByComparator the comparator to order the set by
564            * @return the first matching s c framework version
565            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found
566            * @throws SystemException if a system exception occurred
567            */
568            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByG_A_First(
569                    long groupId, boolean active,
570                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
571                    throws com.liferay.portal.kernel.exception.SystemException,
572                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
573                    return getPersistence()
574                                       .findByG_A_First(groupId, active, orderByComparator);
575            }
576    
577            /**
578            * Finds the last s c framework version in the ordered set where groupId = &#63; and active = &#63;.
579            *
580            * <p>
581            * 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.
582            * </p>
583            *
584            * @param groupId the group id to search with
585            * @param active the active to search with
586            * @param orderByComparator the comparator to order the set by
587            * @return the last matching s c framework version
588            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found
589            * @throws SystemException if a system exception occurred
590            */
591            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByG_A_Last(
592                    long groupId, boolean active,
593                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
594                    throws com.liferay.portal.kernel.exception.SystemException,
595                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
596                    return getPersistence()
597                                       .findByG_A_Last(groupId, active, orderByComparator);
598            }
599    
600            /**
601            * Finds the s c framework versions before and after the current s c framework version in the ordered set where groupId = &#63; and active = &#63;.
602            *
603            * <p>
604            * 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.
605            * </p>
606            *
607            * @param frameworkVersionId the primary key of the current s c framework version
608            * @param groupId the group id to search with
609            * @param active the active to search with
610            * @param orderByComparator the comparator to order the set by
611            * @return the previous, current, and next s c framework version
612            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
613            * @throws SystemException if a system exception occurred
614            */
615            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByG_A_PrevAndNext(
616                    long frameworkVersionId, long groupId, boolean active,
617                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
618                    throws com.liferay.portal.kernel.exception.SystemException,
619                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
620                    return getPersistence()
621                                       .findByG_A_PrevAndNext(frameworkVersionId, groupId, active,
622                            orderByComparator);
623            }
624    
625            /**
626            * Filters by the user's permissions and finds all the s c framework versions where groupId = &#63; and active = &#63;.
627            *
628            * @param groupId the group id to search with
629            * @param active the active to search with
630            * @return the matching s c framework versions that the user has permission to view
631            * @throws SystemException if a system exception occurred
632            */
633            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A(
634                    long groupId, boolean active)
635                    throws com.liferay.portal.kernel.exception.SystemException {
636                    return getPersistence().filterFindByG_A(groupId, active);
637            }
638    
639            /**
640            * Filters by the user's permissions and finds a range of all the s c framework versions where groupId = &#63; and active = &#63;.
641            *
642            * <p>
643            * 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.
644            * </p>
645            *
646            * @param groupId the group id to search with
647            * @param active the active to search with
648            * @param start the lower bound of the range of s c framework versions to return
649            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
650            * @return the range of matching s c framework versions that the user has permission to view
651            * @throws SystemException if a system exception occurred
652            */
653            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A(
654                    long groupId, boolean active, int start, int end)
655                    throws com.liferay.portal.kernel.exception.SystemException {
656                    return getPersistence().filterFindByG_A(groupId, active, start, end);
657            }
658    
659            /**
660            * Filters by the user's permissions and finds an ordered range of all the s c framework versions where groupId = &#63; and active = &#63;.
661            *
662            * <p>
663            * 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.
664            * </p>
665            *
666            * @param groupId the group id to search with
667            * @param active the active to search with
668            * @param start the lower bound of the range of s c framework versions to return
669            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
670            * @param orderByComparator the comparator to order the results by
671            * @return the ordered range of matching s c framework versions that the user has permission to view
672            * @throws SystemException if a system exception occurred
673            */
674            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A(
675                    long groupId, boolean active, int start, int end,
676                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
677                    throws com.liferay.portal.kernel.exception.SystemException {
678                    return getPersistence()
679                                       .filterFindByG_A(groupId, active, start, end,
680                            orderByComparator);
681            }
682    
683            /**
684            * Finds all the s c framework versions.
685            *
686            * @return the s c framework versions
687            * @throws SystemException if a system exception occurred
688            */
689            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll()
690                    throws com.liferay.portal.kernel.exception.SystemException {
691                    return getPersistence().findAll();
692            }
693    
694            /**
695            * Finds a range of all the s c framework versions.
696            *
697            * <p>
698            * 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.
699            * </p>
700            *
701            * @param start the lower bound of the range of s c framework versions to return
702            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
703            * @return the range of s c framework versions
704            * @throws SystemException if a system exception occurred
705            */
706            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll(
707                    int start, int end)
708                    throws com.liferay.portal.kernel.exception.SystemException {
709                    return getPersistence().findAll(start, end);
710            }
711    
712            /**
713            * Finds an ordered range of all the s c framework versions.
714            *
715            * <p>
716            * 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.
717            * </p>
718            *
719            * @param start the lower bound of the range of s c framework versions to return
720            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
721            * @param orderByComparator the comparator to order the results by
722            * @return the ordered range of s c framework versions
723            * @throws SystemException if a system exception occurred
724            */
725            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll(
726                    int start, int end,
727                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
728                    throws com.liferay.portal.kernel.exception.SystemException {
729                    return getPersistence().findAll(start, end, orderByComparator);
730            }
731    
732            /**
733            * Removes all the s c framework versions where groupId = &#63; from the database.
734            *
735            * @param groupId the group id to search with
736            * @throws SystemException if a system exception occurred
737            */
738            public static void removeByGroupId(long groupId)
739                    throws com.liferay.portal.kernel.exception.SystemException {
740                    getPersistence().removeByGroupId(groupId);
741            }
742    
743            /**
744            * Removes all the s c framework versions where companyId = &#63; from the database.
745            *
746            * @param companyId the company id to search with
747            * @throws SystemException if a system exception occurred
748            */
749            public static void removeByCompanyId(long companyId)
750                    throws com.liferay.portal.kernel.exception.SystemException {
751                    getPersistence().removeByCompanyId(companyId);
752            }
753    
754            /**
755            * Removes all the s c framework versions where groupId = &#63; and active = &#63; from the database.
756            *
757            * @param groupId the group id to search with
758            * @param active the active to search with
759            * @throws SystemException if a system exception occurred
760            */
761            public static void removeByG_A(long groupId, boolean active)
762                    throws com.liferay.portal.kernel.exception.SystemException {
763                    getPersistence().removeByG_A(groupId, active);
764            }
765    
766            /**
767            * Removes all the s c framework versions from the database.
768            *
769            * @throws SystemException if a system exception occurred
770            */
771            public static void removeAll()
772                    throws com.liferay.portal.kernel.exception.SystemException {
773                    getPersistence().removeAll();
774            }
775    
776            /**
777            * Counts all the s c framework versions where groupId = &#63;.
778            *
779            * @param groupId the group id to search with
780            * @return the number of matching s c framework versions
781            * @throws SystemException if a system exception occurred
782            */
783            public static int countByGroupId(long groupId)
784                    throws com.liferay.portal.kernel.exception.SystemException {
785                    return getPersistence().countByGroupId(groupId);
786            }
787    
788            /**
789            * Filters by the user's permissions and counts all the s c framework versions where groupId = &#63;.
790            *
791            * @param groupId the group id to search with
792            * @return the number of matching s c framework versions that the user has permission to view
793            * @throws SystemException if a system exception occurred
794            */
795            public static int filterCountByGroupId(long groupId)
796                    throws com.liferay.portal.kernel.exception.SystemException {
797                    return getPersistence().filterCountByGroupId(groupId);
798            }
799    
800            /**
801            * Counts all the s c framework versions where companyId = &#63;.
802            *
803            * @param companyId the company id to search with
804            * @return the number of matching s c framework versions
805            * @throws SystemException if a system exception occurred
806            */
807            public static int countByCompanyId(long companyId)
808                    throws com.liferay.portal.kernel.exception.SystemException {
809                    return getPersistence().countByCompanyId(companyId);
810            }
811    
812            /**
813            * Counts all the s c framework versions where groupId = &#63; and active = &#63;.
814            *
815            * @param groupId the group id to search with
816            * @param active the active to search with
817            * @return the number of matching s c framework versions
818            * @throws SystemException if a system exception occurred
819            */
820            public static int countByG_A(long groupId, boolean active)
821                    throws com.liferay.portal.kernel.exception.SystemException {
822                    return getPersistence().countByG_A(groupId, active);
823            }
824    
825            /**
826            * Filters by the user's permissions and counts all the s c framework versions where groupId = &#63; and active = &#63;.
827            *
828            * @param groupId the group id to search with
829            * @param active the active to search with
830            * @return the number of matching s c framework versions that the user has permission to view
831            * @throws SystemException if a system exception occurred
832            */
833            public static int filterCountByG_A(long groupId, boolean active)
834                    throws com.liferay.portal.kernel.exception.SystemException {
835                    return getPersistence().filterCountByG_A(groupId, active);
836            }
837    
838            /**
839            * Counts all the s c framework versions.
840            *
841            * @return the number of s c framework versions
842            * @throws SystemException if a system exception occurred
843            */
844            public static int countAll()
845                    throws com.liferay.portal.kernel.exception.SystemException {
846                    return getPersistence().countAll();
847            }
848    
849            /**
850            * Gets all the s c product versions associated with the s c framework version.
851            *
852            * @param pk the primary key of the s c framework version to get the associated s c product versions for
853            * @return the s c product versions associated with the s c framework version
854            * @throws SystemException if a system exception occurred
855            */
856            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
857                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
858                    return getPersistence().getSCProductVersions(pk);
859            }
860    
861            /**
862            * Gets a range of all the s c product versions associated with the s c framework version.
863            *
864            * <p>
865            * 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.
866            * </p>
867            *
868            * @param pk the primary key of the s c framework version to get the associated s c product versions for
869            * @param start the lower bound of the range of s c framework versions to return
870            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
871            * @return the range of s c product versions associated with the s c framework version
872            * @throws SystemException if a system exception occurred
873            */
874            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
875                    long pk, int start, int end)
876                    throws com.liferay.portal.kernel.exception.SystemException {
877                    return getPersistence().getSCProductVersions(pk, start, end);
878            }
879    
880            /**
881            * Gets an ordered range of all the s c product versions associated with the s c framework version.
882            *
883            * <p>
884            * 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.
885            * </p>
886            *
887            * @param pk the primary key of the s c framework version to get the associated s c product versions for
888            * @param start the lower bound of the range of s c framework versions to return
889            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
890            * @param orderByComparator the comparator to order the results by
891            * @return the ordered range of s c product versions associated with the s c framework version
892            * @throws SystemException if a system exception occurred
893            */
894            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
895                    long pk, int start, int end,
896                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
897                    throws com.liferay.portal.kernel.exception.SystemException {
898                    return getPersistence()
899                                       .getSCProductVersions(pk, start, end, orderByComparator);
900            }
901    
902            /**
903            * Gets the number of s c product versions associated with the s c framework version.
904            *
905            * @param pk the primary key of the s c framework version to get the number of associated s c product versions for
906            * @return the number of s c product versions associated with the s c framework version
907            * @throws SystemException if a system exception occurred
908            */
909            public static int getSCProductVersionsSize(long pk)
910                    throws com.liferay.portal.kernel.exception.SystemException {
911                    return getPersistence().getSCProductVersionsSize(pk);
912            }
913    
914            /**
915            * Determines whether the s c product version is associated with the s c framework version.
916            *
917            * @param pk the primary key of the s c framework version
918            * @param scProductVersionPK the primary key of the s c product version
919            * @return whether the s c product version is associated with the s c framework version
920            * @throws SystemException if a system exception occurred
921            */
922            public static boolean containsSCProductVersion(long pk,
923                    long scProductVersionPK)
924                    throws com.liferay.portal.kernel.exception.SystemException {
925                    return getPersistence().containsSCProductVersion(pk, scProductVersionPK);
926            }
927    
928            /**
929            * Determines whether the s c framework version has any s c product versions associated with it.
930            *
931            * @param pk the primary key of the s c framework version to check for associations with s c product versions
932            * @return whether the s c framework version has any s c product versions associated with it
933            * @throws SystemException if a system exception occurred
934            */
935            public static boolean containsSCProductVersions(long pk)
936                    throws com.liferay.portal.kernel.exception.SystemException {
937                    return getPersistence().containsSCProductVersions(pk);
938            }
939    
940            /**
941            * Adds an association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
942            *
943            * @param pk the primary key of the s c framework version
944            * @param scProductVersionPK the primary key of the s c product version
945            * @throws SystemException if a system exception occurred
946            */
947            public static void addSCProductVersion(long pk, long scProductVersionPK)
948                    throws com.liferay.portal.kernel.exception.SystemException {
949                    getPersistence().addSCProductVersion(pk, scProductVersionPK);
950            }
951    
952            /**
953            * Adds an association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
954            *
955            * @param pk the primary key of the s c framework version
956            * @param scProductVersion the s c product version
957            * @throws SystemException if a system exception occurred
958            */
959            public static void addSCProductVersion(long pk,
960                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
961                    throws com.liferay.portal.kernel.exception.SystemException {
962                    getPersistence().addSCProductVersion(pk, scProductVersion);
963            }
964    
965            /**
966            * Adds an association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
967            *
968            * @param pk the primary key of the s c framework version
969            * @param scProductVersionPKs the primary keys of the s c product versions
970            * @throws SystemException if a system exception occurred
971            */
972            public static void addSCProductVersions(long pk, long[] scProductVersionPKs)
973                    throws com.liferay.portal.kernel.exception.SystemException {
974                    getPersistence().addSCProductVersions(pk, scProductVersionPKs);
975            }
976    
977            /**
978            * Adds an association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
979            *
980            * @param pk the primary key of the s c framework version
981            * @param scProductVersions the s c product versions
982            * @throws SystemException if a system exception occurred
983            */
984            public static void addSCProductVersions(long pk,
985                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions)
986                    throws com.liferay.portal.kernel.exception.SystemException {
987                    getPersistence().addSCProductVersions(pk, scProductVersions);
988            }
989    
990            /**
991            * Clears all associations between the s c framework version and its s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
992            *
993            * @param pk the primary key of the s c framework version to clear the associated s c product versions from
994            * @throws SystemException if a system exception occurred
995            */
996            public static void clearSCProductVersions(long pk)
997                    throws com.liferay.portal.kernel.exception.SystemException {
998                    getPersistence().clearSCProductVersions(pk);
999            }
1000    
1001            /**
1002            * Removes the association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1003            *
1004            * @param pk the primary key of the s c framework version
1005            * @param scProductVersionPK the primary key of the s c product version
1006            * @throws SystemException if a system exception occurred
1007            */
1008            public static void removeSCProductVersion(long pk, long scProductVersionPK)
1009                    throws com.liferay.portal.kernel.exception.SystemException {
1010                    getPersistence().removeSCProductVersion(pk, scProductVersionPK);
1011            }
1012    
1013            /**
1014            * Removes the association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1015            *
1016            * @param pk the primary key of the s c framework version
1017            * @param scProductVersion the s c product version
1018            * @throws SystemException if a system exception occurred
1019            */
1020            public static void removeSCProductVersion(long pk,
1021                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
1022                    throws com.liferay.portal.kernel.exception.SystemException {
1023                    getPersistence().removeSCProductVersion(pk, scProductVersion);
1024            }
1025    
1026            /**
1027            * Removes the association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1028            *
1029            * @param pk the primary key of the s c framework version
1030            * @param scProductVersionPKs the primary keys of the s c product versions
1031            * @throws SystemException if a system exception occurred
1032            */
1033            public static void removeSCProductVersions(long pk,
1034                    long[] scProductVersionPKs)
1035                    throws com.liferay.portal.kernel.exception.SystemException {
1036                    getPersistence().removeSCProductVersions(pk, scProductVersionPKs);
1037            }
1038    
1039            /**
1040            * Removes the association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1041            *
1042            * @param pk the primary key of the s c framework version
1043            * @param scProductVersions the s c product versions
1044            * @throws SystemException if a system exception occurred
1045            */
1046            public static void removeSCProductVersions(long pk,
1047                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions)
1048                    throws com.liferay.portal.kernel.exception.SystemException {
1049                    getPersistence().removeSCProductVersions(pk, scProductVersions);
1050            }
1051    
1052            /**
1053            * Sets the s c product versions associated with the s c framework version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1054            *
1055            * @param pk the primary key of the s c framework version to set the associations for
1056            * @param scProductVersionPKs the primary keys of the s c product versions to be associated with the s c framework version
1057            * @throws SystemException if a system exception occurred
1058            */
1059            public static void setSCProductVersions(long pk, long[] scProductVersionPKs)
1060                    throws com.liferay.portal.kernel.exception.SystemException {
1061                    getPersistence().setSCProductVersions(pk, scProductVersionPKs);
1062            }
1063    
1064            /**
1065            * Sets the s c product versions associated with the s c framework version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1066            *
1067            * @param pk the primary key of the s c framework version to set the associations for
1068            * @param scProductVersions the s c product versions to be associated with the s c framework version
1069            * @throws SystemException if a system exception occurred
1070            */
1071            public static void setSCProductVersions(long pk,
1072                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions)
1073                    throws com.liferay.portal.kernel.exception.SystemException {
1074                    getPersistence().setSCProductVersions(pk, scProductVersions);
1075            }
1076    
1077            public static SCFrameworkVersionPersistence getPersistence() {
1078                    if (_persistence == null) {
1079                            _persistence = (SCFrameworkVersionPersistence)PortalBeanLocatorUtil.locate(SCFrameworkVersionPersistence.class.getName());
1080                    }
1081    
1082                    return _persistence;
1083            }
1084    
1085            public void setPersistence(SCFrameworkVersionPersistence persistence) {
1086                    _persistence = persistence;
1087            }
1088    
1089            private static SCFrameworkVersionPersistence _persistence;
1090    }