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