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