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