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