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