001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.softwarecatalog.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.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 to cache
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 to cache
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 to remove
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            * Finds the s c framework version with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException} if it could not be found.
178            *
179            * @param frameworkVersionId the primary key of the s c framework version to find
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            * Finds 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 to find
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            * Finds all the s c framework versions where groupId = &#63;.
206            *
207            * @param groupId the group ID to search with
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            * Finds 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 to search with
225            * @param start the lower bound of the range of s c framework versions to return
226            * @param end the upper bound of the range of s c framework versions to return (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            * Finds 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 to search with
244            * @param start the lower bound of the range of s c framework versions to return
245            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
246            * @param orderByComparator the comparator to order the results by
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            * Finds 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 to search with
266            * @param orderByComparator the comparator to order the set by
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            * Finds 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 to search with
287            * @param orderByComparator the comparator to order the set by
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            * Finds 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 to search with
309            * @param orderByComparator the comparator to order the set by
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            * Filters by the user's permissions and finds all the s c framework versions where groupId = &#63;.
326            *
327            * @param groupId the group ID to search with
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            * Filters by the user's permissions and finds a range of all the s c framework versions 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 to search with
345            * @param start the lower bound of the range of s c framework versions to return
346            * @param end the upper bound of the range of s c framework versions to return (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            * Filters by the user's permissions and finds an ordered range of all the s c framework versions 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 to search with
364            * @param start the lower bound of the range of s c framework versions to return
365            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
366            * @param orderByComparator the comparator to order the results by
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            * Filters the s c framework versions before and after the current s c framework version in the ordered set where groupId = &#63;.
380            *
381            * <p>
382            * 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.
383            * </p>
384            *
385            * @param frameworkVersionId the primary key of the current s c framework version
386            * @param groupId the group ID to search with
387            * @param orderByComparator the comparator to order the set by
388            * @return the previous, current, and next s c framework version
389            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
390            * @throws SystemException if a system exception occurred
391            */
392            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] filterFindByGroupId_PrevAndNext(
393                    long frameworkVersionId, long groupId,
394                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
395                    throws com.liferay.portal.kernel.exception.SystemException,
396                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
397                    return getPersistence()
398                                       .filterFindByGroupId_PrevAndNext(frameworkVersionId,
399                            groupId, orderByComparator);
400            }
401    
402            /**
403            * Finds all the s c framework versions where companyId = &#63;.
404            *
405            * @param companyId the company ID to search with
406            * @return the matching s c framework versions
407            * @throws SystemException if a system exception occurred
408            */
409            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId(
410                    long companyId)
411                    throws com.liferay.portal.kernel.exception.SystemException {
412                    return getPersistence().findByCompanyId(companyId);
413            }
414    
415            /**
416            * Finds a range of all the s c framework versions where companyId = &#63;.
417            *
418            * <p>
419            * 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.
420            * </p>
421            *
422            * @param companyId the company ID to search with
423            * @param start the lower bound of the range of s c framework versions to return
424            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
425            * @return the range of matching s c framework versions
426            * @throws SystemException if a system exception occurred
427            */
428            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId(
429                    long companyId, int start, int end)
430                    throws com.liferay.portal.kernel.exception.SystemException {
431                    return getPersistence().findByCompanyId(companyId, start, end);
432            }
433    
434            /**
435            * Finds an ordered range of all the s c framework versions where companyId = &#63;.
436            *
437            * <p>
438            * 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.
439            * </p>
440            *
441            * @param companyId the company ID to search with
442            * @param start the lower bound of the range of s c framework versions to return
443            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
444            * @param orderByComparator the comparator to order the results by
445            * @return the ordered range of matching s c framework versions
446            * @throws SystemException if a system exception occurred
447            */
448            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId(
449                    long companyId, int start, int end,
450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
451                    throws com.liferay.portal.kernel.exception.SystemException {
452                    return getPersistence()
453                                       .findByCompanyId(companyId, start, end, orderByComparator);
454            }
455    
456            /**
457            * Finds the first s c framework version in the ordered set where companyId = &#63;.
458            *
459            * <p>
460            * 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.
461            * </p>
462            *
463            * @param companyId the company ID to search with
464            * @param orderByComparator the comparator to order the set by
465            * @return the first matching s c framework version
466            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found
467            * @throws SystemException if a system exception occurred
468            */
469            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByCompanyId_First(
470                    long companyId,
471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
472                    throws com.liferay.portal.kernel.exception.SystemException,
473                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
474                    return getPersistence()
475                                       .findByCompanyId_First(companyId, orderByComparator);
476            }
477    
478            /**
479            * Finds the last s c framework version in the ordered set where companyId = &#63;.
480            *
481            * <p>
482            * 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.
483            * </p>
484            *
485            * @param companyId the company ID to search with
486            * @param orderByComparator the comparator to order the set by
487            * @return the last matching s c framework version
488            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found
489            * @throws SystemException if a system exception occurred
490            */
491            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByCompanyId_Last(
492                    long companyId,
493                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
494                    throws com.liferay.portal.kernel.exception.SystemException,
495                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
496                    return getPersistence()
497                                       .findByCompanyId_Last(companyId, orderByComparator);
498            }
499    
500            /**
501            * Finds the s c framework versions before and after the current s c framework version in the ordered set where companyId = &#63;.
502            *
503            * <p>
504            * 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.
505            * </p>
506            *
507            * @param frameworkVersionId the primary key of the current s c framework version
508            * @param companyId the company ID to search with
509            * @param orderByComparator the comparator to order the set by
510            * @return the previous, current, and next s c framework version
511            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
512            * @throws SystemException if a system exception occurred
513            */
514            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByCompanyId_PrevAndNext(
515                    long frameworkVersionId, long companyId,
516                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
517                    throws com.liferay.portal.kernel.exception.SystemException,
518                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
519                    return getPersistence()
520                                       .findByCompanyId_PrevAndNext(frameworkVersionId, companyId,
521                            orderByComparator);
522            }
523    
524            /**
525            * Finds all the s c framework versions where groupId = &#63; and active = &#63;.
526            *
527            * @param groupId the group ID to search with
528            * @param active the active to search with
529            * @return the matching s c framework versions
530            * @throws SystemException if a system exception occurred
531            */
532            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A(
533                    long groupId, boolean active)
534                    throws com.liferay.portal.kernel.exception.SystemException {
535                    return getPersistence().findByG_A(groupId, active);
536            }
537    
538            /**
539            * Finds a range of all the s c framework versions where groupId = &#63; and active = &#63;.
540            *
541            * <p>
542            * 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.
543            * </p>
544            *
545            * @param groupId the group ID to search with
546            * @param active the active to search with
547            * @param start the lower bound of the range of s c framework versions to return
548            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
549            * @return the range of matching s c framework versions
550            * @throws SystemException if a system exception occurred
551            */
552            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A(
553                    long groupId, boolean active, int start, int end)
554                    throws com.liferay.portal.kernel.exception.SystemException {
555                    return getPersistence().findByG_A(groupId, active, start, end);
556            }
557    
558            /**
559            * Finds an ordered range of all the s c framework versions where groupId = &#63; and active = &#63;.
560            *
561            * <p>
562            * 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.
563            * </p>
564            *
565            * @param groupId the group ID to search with
566            * @param active the active to search with
567            * @param start the lower bound of the range of s c framework versions to return
568            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
569            * @param orderByComparator the comparator to order the results by
570            * @return the ordered range of matching s c framework versions
571            * @throws SystemException if a system exception occurred
572            */
573            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A(
574                    long groupId, boolean active, int start, int end,
575                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
576                    throws com.liferay.portal.kernel.exception.SystemException {
577                    return getPersistence()
578                                       .findByG_A(groupId, active, start, end, orderByComparator);
579            }
580    
581            /**
582            * Finds the first s c framework version in the ordered set where groupId = &#63; and active = &#63;.
583            *
584            * <p>
585            * 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.
586            * </p>
587            *
588            * @param groupId the group ID to search with
589            * @param active the active to search with
590            * @param orderByComparator the comparator to order the set by
591            * @return the first matching s c framework version
592            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found
593            * @throws SystemException if a system exception occurred
594            */
595            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByG_A_First(
596                    long groupId, boolean active,
597                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
598                    throws com.liferay.portal.kernel.exception.SystemException,
599                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
600                    return getPersistence()
601                                       .findByG_A_First(groupId, active, orderByComparator);
602            }
603    
604            /**
605            * Finds the last s c framework version in the ordered set where groupId = &#63; and active = &#63;.
606            *
607            * <p>
608            * 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.
609            * </p>
610            *
611            * @param groupId the group ID to search with
612            * @param active the active to search with
613            * @param orderByComparator the comparator to order the set by
614            * @return the last matching s c framework version
615            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found
616            * @throws SystemException if a system exception occurred
617            */
618            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByG_A_Last(
619                    long groupId, boolean active,
620                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
621                    throws com.liferay.portal.kernel.exception.SystemException,
622                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
623                    return getPersistence()
624                                       .findByG_A_Last(groupId, active, orderByComparator);
625            }
626    
627            /**
628            * Finds the s c framework versions before and after the current s c framework version in the ordered set where groupId = &#63; and active = &#63;.
629            *
630            * <p>
631            * 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.
632            * </p>
633            *
634            * @param frameworkVersionId the primary key of the current s c framework version
635            * @param groupId the group ID to search with
636            * @param active the active to search with
637            * @param orderByComparator the comparator to order the set by
638            * @return the previous, current, and next s c framework version
639            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
640            * @throws SystemException if a system exception occurred
641            */
642            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByG_A_PrevAndNext(
643                    long frameworkVersionId, long groupId, boolean active,
644                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
645                    throws com.liferay.portal.kernel.exception.SystemException,
646                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
647                    return getPersistence()
648                                       .findByG_A_PrevAndNext(frameworkVersionId, groupId, active,
649                            orderByComparator);
650            }
651    
652            /**
653            * Filters by the user's permissions and finds all the s c framework versions where groupId = &#63; and active = &#63;.
654            *
655            * @param groupId the group ID to search with
656            * @param active the active to search with
657            * @return the matching s c framework versions that the user has permission to view
658            * @throws SystemException if a system exception occurred
659            */
660            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A(
661                    long groupId, boolean active)
662                    throws com.liferay.portal.kernel.exception.SystemException {
663                    return getPersistence().filterFindByG_A(groupId, active);
664            }
665    
666            /**
667            * Filters by the user's permissions and finds a range of all the s c framework versions where groupId = &#63; and active = &#63;.
668            *
669            * <p>
670            * 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.
671            * </p>
672            *
673            * @param groupId the group ID to search with
674            * @param active the active to search with
675            * @param start the lower bound of the range of s c framework versions to return
676            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
677            * @return the range of matching s c framework versions that the user has permission to view
678            * @throws SystemException if a system exception occurred
679            */
680            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A(
681                    long groupId, boolean active, int start, int end)
682                    throws com.liferay.portal.kernel.exception.SystemException {
683                    return getPersistence().filterFindByG_A(groupId, active, start, end);
684            }
685    
686            /**
687            * Filters by the user's permissions and finds an ordered range of all the s c framework versions where groupId = &#63; and active = &#63;.
688            *
689            * <p>
690            * 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.
691            * </p>
692            *
693            * @param groupId the group ID to search with
694            * @param active the active to search with
695            * @param start the lower bound of the range of s c framework versions to return
696            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
697            * @param orderByComparator the comparator to order the results by
698            * @return the ordered range of matching s c framework versions that the user has permission to view
699            * @throws SystemException if a system exception occurred
700            */
701            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A(
702                    long groupId, boolean active, int start, int end,
703                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
704                    throws com.liferay.portal.kernel.exception.SystemException {
705                    return getPersistence()
706                                       .filterFindByG_A(groupId, active, start, end,
707                            orderByComparator);
708            }
709    
710            /**
711            * Filters the s c framework versions before and after the current s c framework version in the ordered set where groupId = &#63; and active = &#63;.
712            *
713            * <p>
714            * 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.
715            * </p>
716            *
717            * @param frameworkVersionId the primary key of the current s c framework version
718            * @param groupId the group ID to search with
719            * @param active the active to search with
720            * @param orderByComparator the comparator to order the set by
721            * @return the previous, current, and next s c framework version
722            * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
723            * @throws SystemException if a system exception occurred
724            */
725            public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] filterFindByG_A_PrevAndNext(
726                    long frameworkVersionId, long groupId, boolean active,
727                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
728                    throws com.liferay.portal.kernel.exception.SystemException,
729                            com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException {
730                    return getPersistence()
731                                       .filterFindByG_A_PrevAndNext(frameworkVersionId, groupId,
732                            active, orderByComparator);
733            }
734    
735            /**
736            * Finds all the s c framework versions.
737            *
738            * @return the s c framework versions
739            * @throws SystemException if a system exception occurred
740            */
741            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll()
742                    throws com.liferay.portal.kernel.exception.SystemException {
743                    return getPersistence().findAll();
744            }
745    
746            /**
747            * Finds a range of all the s c framework versions.
748            *
749            * <p>
750            * 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.
751            * </p>
752            *
753            * @param start the lower bound of the range of s c framework versions to return
754            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
755            * @return the range of s c framework versions
756            * @throws SystemException if a system exception occurred
757            */
758            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll(
759                    int start, int end)
760                    throws com.liferay.portal.kernel.exception.SystemException {
761                    return getPersistence().findAll(start, end);
762            }
763    
764            /**
765            * Finds an ordered range of all the s c framework versions.
766            *
767            * <p>
768            * 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.
769            * </p>
770            *
771            * @param start the lower bound of the range of s c framework versions to return
772            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
773            * @param orderByComparator the comparator to order the results by
774            * @return the ordered range of s c framework versions
775            * @throws SystemException if a system exception occurred
776            */
777            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll(
778                    int start, int end,
779                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
780                    throws com.liferay.portal.kernel.exception.SystemException {
781                    return getPersistence().findAll(start, end, orderByComparator);
782            }
783    
784            /**
785            * Removes all the s c framework versions where groupId = &#63; from the database.
786            *
787            * @param groupId the group ID to search with
788            * @throws SystemException if a system exception occurred
789            */
790            public static void removeByGroupId(long groupId)
791                    throws com.liferay.portal.kernel.exception.SystemException {
792                    getPersistence().removeByGroupId(groupId);
793            }
794    
795            /**
796            * Removes all the s c framework versions where companyId = &#63; from the database.
797            *
798            * @param companyId the company ID to search with
799            * @throws SystemException if a system exception occurred
800            */
801            public static void removeByCompanyId(long companyId)
802                    throws com.liferay.portal.kernel.exception.SystemException {
803                    getPersistence().removeByCompanyId(companyId);
804            }
805    
806            /**
807            * Removes all the s c framework versions where groupId = &#63; and active = &#63; from the database.
808            *
809            * @param groupId the group ID to search with
810            * @param active the active to search with
811            * @throws SystemException if a system exception occurred
812            */
813            public static void removeByG_A(long groupId, boolean active)
814                    throws com.liferay.portal.kernel.exception.SystemException {
815                    getPersistence().removeByG_A(groupId, active);
816            }
817    
818            /**
819            * Removes all the s c framework versions from the database.
820            *
821            * @throws SystemException if a system exception occurred
822            */
823            public static void removeAll()
824                    throws com.liferay.portal.kernel.exception.SystemException {
825                    getPersistence().removeAll();
826            }
827    
828            /**
829            * Counts all the s c framework versions where groupId = &#63;.
830            *
831            * @param groupId the group ID to search with
832            * @return the number of matching s c framework versions
833            * @throws SystemException if a system exception occurred
834            */
835            public static int countByGroupId(long groupId)
836                    throws com.liferay.portal.kernel.exception.SystemException {
837                    return getPersistence().countByGroupId(groupId);
838            }
839    
840            /**
841            * Filters by the user's permissions and counts all the s c framework versions where groupId = &#63;.
842            *
843            * @param groupId the group ID to search with
844            * @return the number of matching s c framework versions that the user has permission to view
845            * @throws SystemException if a system exception occurred
846            */
847            public static int filterCountByGroupId(long groupId)
848                    throws com.liferay.portal.kernel.exception.SystemException {
849                    return getPersistence().filterCountByGroupId(groupId);
850            }
851    
852            /**
853            * Counts all the s c framework versions where companyId = &#63;.
854            *
855            * @param companyId the company ID to search with
856            * @return the number of matching s c framework versions
857            * @throws SystemException if a system exception occurred
858            */
859            public static int countByCompanyId(long companyId)
860                    throws com.liferay.portal.kernel.exception.SystemException {
861                    return getPersistence().countByCompanyId(companyId);
862            }
863    
864            /**
865            * Counts all the s c framework versions where groupId = &#63; and active = &#63;.
866            *
867            * @param groupId the group ID to search with
868            * @param active the active to search with
869            * @return the number of matching s c framework versions
870            * @throws SystemException if a system exception occurred
871            */
872            public static int countByG_A(long groupId, boolean active)
873                    throws com.liferay.portal.kernel.exception.SystemException {
874                    return getPersistence().countByG_A(groupId, active);
875            }
876    
877            /**
878            * Filters by the user's permissions and counts all the s c framework versions where groupId = &#63; and active = &#63;.
879            *
880            * @param groupId the group ID to search with
881            * @param active the active to search with
882            * @return the number of matching s c framework versions that the user has permission to view
883            * @throws SystemException if a system exception occurred
884            */
885            public static int filterCountByG_A(long groupId, boolean active)
886                    throws com.liferay.portal.kernel.exception.SystemException {
887                    return getPersistence().filterCountByG_A(groupId, active);
888            }
889    
890            /**
891            * Counts all the s c framework versions.
892            *
893            * @return the number of s c framework versions
894            * @throws SystemException if a system exception occurred
895            */
896            public static int countAll()
897                    throws com.liferay.portal.kernel.exception.SystemException {
898                    return getPersistence().countAll();
899            }
900    
901            /**
902            * Gets all the s c product versions associated with the s c framework version.
903            *
904            * @param pk the primary key of the s c framework version to get the associated s c product versions for
905            * @return the s c product versions associated with the s c framework version
906            * @throws SystemException if a system exception occurred
907            */
908            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
909                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
910                    return getPersistence().getSCProductVersions(pk);
911            }
912    
913            /**
914            * Gets a range of all the s c product versions associated with the s c framework version.
915            *
916            * <p>
917            * 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.
918            * </p>
919            *
920            * @param pk the primary key of the s c framework version to get the associated s c product versions for
921            * @param start the lower bound of the range of s c framework versions to return
922            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
923            * @return the range of s c product versions associated with the s c framework version
924            * @throws SystemException if a system exception occurred
925            */
926            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
927                    long pk, int start, int end)
928                    throws com.liferay.portal.kernel.exception.SystemException {
929                    return getPersistence().getSCProductVersions(pk, start, end);
930            }
931    
932            /**
933            * Gets an ordered range of all the s c product versions associated with the s c framework version.
934            *
935            * <p>
936            * 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.
937            * </p>
938            *
939            * @param pk the primary key of the s c framework version to get the associated s c product versions for
940            * @param start the lower bound of the range of s c framework versions to return
941            * @param end the upper bound of the range of s c framework versions to return (not inclusive)
942            * @param orderByComparator the comparator to order the results by
943            * @return the ordered range of s c product versions associated with the s c framework version
944            * @throws SystemException if a system exception occurred
945            */
946            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
947                    long pk, int start, int end,
948                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
949                    throws com.liferay.portal.kernel.exception.SystemException {
950                    return getPersistence()
951                                       .getSCProductVersions(pk, start, end, orderByComparator);
952            }
953    
954            /**
955            * Gets the number of s c product versions associated with the s c framework version.
956            *
957            * @param pk the primary key of the s c framework version to get the number of associated s c product versions for
958            * @return the number of s c product versions associated with the s c framework version
959            * @throws SystemException if a system exception occurred
960            */
961            public static int getSCProductVersionsSize(long pk)
962                    throws com.liferay.portal.kernel.exception.SystemException {
963                    return getPersistence().getSCProductVersionsSize(pk);
964            }
965    
966            /**
967            * Determines if the s c product version is associated with the s c framework version.
968            *
969            * @param pk the primary key of the s c framework version
970            * @param scProductVersionPK the primary key of the s c product version
971            * @return <code>true</code> if the s c product version is associated with the s c framework version; <code>false</code> otherwise
972            * @throws SystemException if a system exception occurred
973            */
974            public static boolean containsSCProductVersion(long pk,
975                    long scProductVersionPK)
976                    throws com.liferay.portal.kernel.exception.SystemException {
977                    return getPersistence().containsSCProductVersion(pk, scProductVersionPK);
978            }
979    
980            /**
981            * Determines if the s c framework version has any s c product versions associated with it.
982            *
983            * @param pk the primary key of the s c framework version to check for associations with s c product versions
984            * @return <code>true</code> if the s c framework version has any s c product versions associated with it; <code>false</code> otherwise
985            * @throws SystemException if a system exception occurred
986            */
987            public static boolean containsSCProductVersions(long pk)
988                    throws com.liferay.portal.kernel.exception.SystemException {
989                    return getPersistence().containsSCProductVersions(pk);
990            }
991    
992            /**
993            * 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.
994            *
995            * @param pk the primary key of the s c framework version
996            * @param scProductVersionPK the primary key of the s c product version
997            * @throws SystemException if a system exception occurred
998            */
999            public static void addSCProductVersion(long pk, long scProductVersionPK)
1000                    throws com.liferay.portal.kernel.exception.SystemException {
1001                    getPersistence().addSCProductVersion(pk, scProductVersionPK);
1002            }
1003    
1004            /**
1005            * 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.
1006            *
1007            * @param pk the primary key of the s c framework version
1008            * @param scProductVersion the s c product version
1009            * @throws SystemException if a system exception occurred
1010            */
1011            public static void addSCProductVersion(long pk,
1012                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
1013                    throws com.liferay.portal.kernel.exception.SystemException {
1014                    getPersistence().addSCProductVersion(pk, scProductVersion);
1015            }
1016    
1017            /**
1018            * 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.
1019            *
1020            * @param pk the primary key of the s c framework version
1021            * @param scProductVersionPKs the primary keys of the s c product versions
1022            * @throws SystemException if a system exception occurred
1023            */
1024            public static void addSCProductVersions(long pk, long[] scProductVersionPKs)
1025                    throws com.liferay.portal.kernel.exception.SystemException {
1026                    getPersistence().addSCProductVersions(pk, scProductVersionPKs);
1027            }
1028    
1029            /**
1030            * 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.
1031            *
1032            * @param pk the primary key of the s c framework version
1033            * @param scProductVersions the s c product versions
1034            * @throws SystemException if a system exception occurred
1035            */
1036            public static void addSCProductVersions(long pk,
1037                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions)
1038                    throws com.liferay.portal.kernel.exception.SystemException {
1039                    getPersistence().addSCProductVersions(pk, scProductVersions);
1040            }
1041    
1042            /**
1043            * 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.
1044            *
1045            * @param pk the primary key of the s c framework version to clear the associated s c product versions from
1046            * @throws SystemException if a system exception occurred
1047            */
1048            public static void clearSCProductVersions(long pk)
1049                    throws com.liferay.portal.kernel.exception.SystemException {
1050                    getPersistence().clearSCProductVersions(pk);
1051            }
1052    
1053            /**
1054            * 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.
1055            *
1056            * @param pk the primary key of the s c framework version
1057            * @param scProductVersionPK the primary key of the s c product version
1058            * @throws SystemException if a system exception occurred
1059            */
1060            public static void removeSCProductVersion(long pk, long scProductVersionPK)
1061                    throws com.liferay.portal.kernel.exception.SystemException {
1062                    getPersistence().removeSCProductVersion(pk, scProductVersionPK);
1063            }
1064    
1065            /**
1066            * 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.
1067            *
1068            * @param pk the primary key of the s c framework version
1069            * @param scProductVersion the s c product version
1070            * @throws SystemException if a system exception occurred
1071            */
1072            public static void removeSCProductVersion(long pk,
1073                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
1074                    throws com.liferay.portal.kernel.exception.SystemException {
1075                    getPersistence().removeSCProductVersion(pk, scProductVersion);
1076            }
1077    
1078            /**
1079            * 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.
1080            *
1081            * @param pk the primary key of the s c framework version
1082            * @param scProductVersionPKs the primary keys of the s c product versions
1083            * @throws SystemException if a system exception occurred
1084            */
1085            public static void removeSCProductVersions(long pk,
1086                    long[] scProductVersionPKs)
1087                    throws com.liferay.portal.kernel.exception.SystemException {
1088                    getPersistence().removeSCProductVersions(pk, scProductVersionPKs);
1089            }
1090    
1091            /**
1092            * 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.
1093            *
1094            * @param pk the primary key of the s c framework version
1095            * @param scProductVersions the s c product versions
1096            * @throws SystemException if a system exception occurred
1097            */
1098            public static void removeSCProductVersions(long pk,
1099                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions)
1100                    throws com.liferay.portal.kernel.exception.SystemException {
1101                    getPersistence().removeSCProductVersions(pk, scProductVersions);
1102            }
1103    
1104            /**
1105            * 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.
1106            *
1107            * @param pk the primary key of the s c framework version to set the associations for
1108            * @param scProductVersionPKs the primary keys of the s c product versions to be associated with the s c framework version
1109            * @throws SystemException if a system exception occurred
1110            */
1111            public static void setSCProductVersions(long pk, long[] scProductVersionPKs)
1112                    throws com.liferay.portal.kernel.exception.SystemException {
1113                    getPersistence().setSCProductVersions(pk, scProductVersionPKs);
1114            }
1115    
1116            /**
1117            * 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.
1118            *
1119            * @param pk the primary key of the s c framework version to set the associations for
1120            * @param scProductVersions the s c product versions to be associated with the s c framework version
1121            * @throws SystemException if a system exception occurred
1122            */
1123            public static void setSCProductVersions(long pk,
1124                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions)
1125                    throws com.liferay.portal.kernel.exception.SystemException {
1126                    getPersistence().setSCProductVersions(pk, scProductVersions);
1127            }
1128    
1129            public static SCFrameworkVersionPersistence getPersistence() {
1130                    if (_persistence == null) {
1131                            _persistence = (SCFrameworkVersionPersistence)PortalBeanLocatorUtil.locate(SCFrameworkVersionPersistence.class.getName());
1132    
1133                            ReferenceRegistry.registerReference(SCFrameworkVersionUtil.class,
1134                                    "_persistence");
1135                    }
1136    
1137                    return _persistence;
1138            }
1139    
1140            public void setPersistence(SCFrameworkVersionPersistence persistence) {
1141                    _persistence = persistence;
1142    
1143                    ReferenceRegistry.registerReference(SCFrameworkVersionUtil.class,
1144                            "_persistence");
1145            }
1146    
1147            private static SCFrameworkVersionPersistence _persistence;
1148    }