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