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