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