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