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