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.SCProductVersion;
027    
028    import java.util.List;
029    
030    /**
031     * The persistence utility for the s c product version service. This utility wraps {@link SCProductVersionPersistenceImpl} 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 SCProductVersionPersistence
039     * @see SCProductVersionPersistenceImpl
040     * @generated
041     */
042    @ProviderType
043    public class SCProductVersionUtil {
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(SCProductVersion scProductVersion) {
061                    getPersistence().clearCache(scProductVersion);
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<SCProductVersion> 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<SCProductVersion> 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<SCProductVersion> 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 SCProductVersion update(SCProductVersion scProductVersion)
104                    throws SystemException {
105                    return getPersistence().update(scProductVersion);
106            }
107    
108            /**
109             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
110             */
111            public static SCProductVersion update(SCProductVersion scProductVersion,
112                    ServiceContext serviceContext) throws SystemException {
113                    return getPersistence().update(scProductVersion, serviceContext);
114            }
115    
116            /**
117            * Returns all the s c product versions where productEntryId = &#63;.
118            *
119            * @param productEntryId the product entry ID
120            * @return the matching s c product versions
121            * @throws SystemException if a system exception occurred
122            */
123            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId(
124                    long productEntryId)
125                    throws com.liferay.portal.kernel.exception.SystemException {
126                    return getPersistence().findByProductEntryId(productEntryId);
127            }
128    
129            /**
130            * Returns a range of all the s c product versions where productEntryId = &#63;.
131            *
132            * <p>
133            * 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.SCProductVersionModelImpl}. 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.
134            * </p>
135            *
136            * @param productEntryId the product entry ID
137            * @param start the lower bound of the range of s c product versions
138            * @param end the upper bound of the range of s c product versions (not inclusive)
139            * @return the range of matching s c product versions
140            * @throws SystemException if a system exception occurred
141            */
142            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId(
143                    long productEntryId, int start, int end)
144                    throws com.liferay.portal.kernel.exception.SystemException {
145                    return getPersistence().findByProductEntryId(productEntryId, start, end);
146            }
147    
148            /**
149            * Returns an ordered range of all the s c product versions where productEntryId = &#63;.
150            *
151            * <p>
152            * 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.SCProductVersionModelImpl}. 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.
153            * </p>
154            *
155            * @param productEntryId the product entry ID
156            * @param start the lower bound of the range of s c product versions
157            * @param end the upper bound of the range of s c product versions (not inclusive)
158            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
159            * @return the ordered range of matching s c product versions
160            * @throws SystemException if a system exception occurred
161            */
162            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId(
163                    long productEntryId, int start, int end,
164                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
165                    throws com.liferay.portal.kernel.exception.SystemException {
166                    return getPersistence()
167                                       .findByProductEntryId(productEntryId, start, end,
168                            orderByComparator);
169            }
170    
171            /**
172            * Returns the first s c product version in the ordered set where productEntryId = &#63;.
173            *
174            * @param productEntryId the product entry ID
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching s c product version
177            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found
178            * @throws SystemException if a system exception occurred
179            */
180            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByProductEntryId_First(
181                    long productEntryId,
182                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
183                    throws com.liferay.portal.kernel.exception.SystemException,
184                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
185                    return getPersistence()
186                                       .findByProductEntryId_First(productEntryId, orderByComparator);
187            }
188    
189            /**
190            * Returns the first s c product version in the ordered set where productEntryId = &#63;.
191            *
192            * @param productEntryId the product entry ID
193            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
194            * @return the first matching s c product version, or <code>null</code> if a matching s c product version could not be found
195            * @throws SystemException if a system exception occurred
196            */
197            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByProductEntryId_First(
198                    long productEntryId,
199                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
200                    throws com.liferay.portal.kernel.exception.SystemException {
201                    return getPersistence()
202                                       .fetchByProductEntryId_First(productEntryId,
203                            orderByComparator);
204            }
205    
206            /**
207            * Returns the last s c product version in the ordered set where productEntryId = &#63;.
208            *
209            * @param productEntryId the product entry ID
210            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
211            * @return the last matching s c product version
212            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found
213            * @throws SystemException if a system exception occurred
214            */
215            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByProductEntryId_Last(
216                    long productEntryId,
217                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
218                    throws com.liferay.portal.kernel.exception.SystemException,
219                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
220                    return getPersistence()
221                                       .findByProductEntryId_Last(productEntryId, orderByComparator);
222            }
223    
224            /**
225            * Returns the last s c product version in the ordered set where productEntryId = &#63;.
226            *
227            * @param productEntryId the product entry ID
228            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
229            * @return the last matching s c product version, or <code>null</code> if a matching s c product version could not be found
230            * @throws SystemException if a system exception occurred
231            */
232            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByProductEntryId_Last(
233                    long productEntryId,
234                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
235                    throws com.liferay.portal.kernel.exception.SystemException {
236                    return getPersistence()
237                                       .fetchByProductEntryId_Last(productEntryId, orderByComparator);
238            }
239    
240            /**
241            * Returns the s c product versions before and after the current s c product version in the ordered set where productEntryId = &#63;.
242            *
243            * @param productVersionId the primary key of the current s c product version
244            * @param productEntryId the product entry ID
245            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
246            * @return the previous, current, and next s c product version
247            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found
248            * @throws SystemException if a system exception occurred
249            */
250            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion[] findByProductEntryId_PrevAndNext(
251                    long productVersionId, long productEntryId,
252                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
253                    throws com.liferay.portal.kernel.exception.SystemException,
254                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
255                    return getPersistence()
256                                       .findByProductEntryId_PrevAndNext(productVersionId,
257                            productEntryId, orderByComparator);
258            }
259    
260            /**
261            * Removes all the s c product versions where productEntryId = &#63; from the database.
262            *
263            * @param productEntryId the product entry ID
264            * @throws SystemException if a system exception occurred
265            */
266            public static void removeByProductEntryId(long productEntryId)
267                    throws com.liferay.portal.kernel.exception.SystemException {
268                    getPersistence().removeByProductEntryId(productEntryId);
269            }
270    
271            /**
272            * Returns the number of s c product versions where productEntryId = &#63;.
273            *
274            * @param productEntryId the product entry ID
275            * @return the number of matching s c product versions
276            * @throws SystemException if a system exception occurred
277            */
278            public static int countByProductEntryId(long productEntryId)
279                    throws com.liferay.portal.kernel.exception.SystemException {
280                    return getPersistence().countByProductEntryId(productEntryId);
281            }
282    
283            /**
284            * Returns the s c product version where directDownloadURL = &#63; or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchProductVersionException} if it could not be found.
285            *
286            * @param directDownloadURL the direct download u r l
287            * @return the matching s c product version
288            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found
289            * @throws SystemException if a system exception occurred
290            */
291            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByDirectDownloadURL(
292                    java.lang.String directDownloadURL)
293                    throws com.liferay.portal.kernel.exception.SystemException,
294                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
295                    return getPersistence().findByDirectDownloadURL(directDownloadURL);
296            }
297    
298            /**
299            * Returns the s c product version where directDownloadURL = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
300            *
301            * @param directDownloadURL the direct download u r l
302            * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found
303            * @throws SystemException if a system exception occurred
304            */
305            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL(
306                    java.lang.String directDownloadURL)
307                    throws com.liferay.portal.kernel.exception.SystemException {
308                    return getPersistence().fetchByDirectDownloadURL(directDownloadURL);
309            }
310    
311            /**
312            * Returns the s c product version where directDownloadURL = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
313            *
314            * @param directDownloadURL the direct download u r l
315            * @param retrieveFromCache whether to use the finder cache
316            * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found
317            * @throws SystemException if a system exception occurred
318            */
319            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL(
320                    java.lang.String directDownloadURL, boolean retrieveFromCache)
321                    throws com.liferay.portal.kernel.exception.SystemException {
322                    return getPersistence()
323                                       .fetchByDirectDownloadURL(directDownloadURL,
324                            retrieveFromCache);
325            }
326    
327            /**
328            * Removes the s c product version where directDownloadURL = &#63; from the database.
329            *
330            * @param directDownloadURL the direct download u r l
331            * @return the s c product version that was removed
332            * @throws SystemException if a system exception occurred
333            */
334            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion removeByDirectDownloadURL(
335                    java.lang.String directDownloadURL)
336                    throws com.liferay.portal.kernel.exception.SystemException,
337                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
338                    return getPersistence().removeByDirectDownloadURL(directDownloadURL);
339            }
340    
341            /**
342            * Returns the number of s c product versions where directDownloadURL = &#63;.
343            *
344            * @param directDownloadURL the direct download u r l
345            * @return the number of matching s c product versions
346            * @throws SystemException if a system exception occurred
347            */
348            public static int countByDirectDownloadURL(
349                    java.lang.String directDownloadURL)
350                    throws com.liferay.portal.kernel.exception.SystemException {
351                    return getPersistence().countByDirectDownloadURL(directDownloadURL);
352            }
353    
354            /**
355            * Caches the s c product version in the entity cache if it is enabled.
356            *
357            * @param scProductVersion the s c product version
358            */
359            public static void cacheResult(
360                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) {
361                    getPersistence().cacheResult(scProductVersion);
362            }
363    
364            /**
365            * Caches the s c product versions in the entity cache if it is enabled.
366            *
367            * @param scProductVersions the s c product versions
368            */
369            public static void cacheResult(
370                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) {
371                    getPersistence().cacheResult(scProductVersions);
372            }
373    
374            /**
375            * Creates a new s c product version with the primary key. Does not add the s c product version to the database.
376            *
377            * @param productVersionId the primary key for the new s c product version
378            * @return the new s c product version
379            */
380            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion create(
381                    long productVersionId) {
382                    return getPersistence().create(productVersionId);
383            }
384    
385            /**
386            * Removes the s c product version with the primary key from the database. Also notifies the appropriate model listeners.
387            *
388            * @param productVersionId the primary key of the s c product version
389            * @return the s c product version that was removed
390            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found
391            * @throws SystemException if a system exception occurred
392            */
393            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion remove(
394                    long productVersionId)
395                    throws com.liferay.portal.kernel.exception.SystemException,
396                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
397                    return getPersistence().remove(productVersionId);
398            }
399    
400            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion updateImpl(
401                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
402                    throws com.liferay.portal.kernel.exception.SystemException {
403                    return getPersistence().updateImpl(scProductVersion);
404            }
405    
406            /**
407            * Returns the s c product version with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchProductVersionException} if it could not be found.
408            *
409            * @param productVersionId the primary key of the s c product version
410            * @return the s c product version
411            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found
412            * @throws SystemException if a system exception occurred
413            */
414            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByPrimaryKey(
415                    long productVersionId)
416                    throws com.liferay.portal.kernel.exception.SystemException,
417                            com.liferay.portlet.softwarecatalog.NoSuchProductVersionException {
418                    return getPersistence().findByPrimaryKey(productVersionId);
419            }
420    
421            /**
422            * Returns the s c product version with the primary key or returns <code>null</code> if it could not be found.
423            *
424            * @param productVersionId the primary key of the s c product version
425            * @return the s c product version, or <code>null</code> if a s c product version with the primary key could not be found
426            * @throws SystemException if a system exception occurred
427            */
428            public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByPrimaryKey(
429                    long productVersionId)
430                    throws com.liferay.portal.kernel.exception.SystemException {
431                    return getPersistence().fetchByPrimaryKey(productVersionId);
432            }
433    
434            /**
435            * Returns all the s c product versions.
436            *
437            * @return the s c product versions
438            * @throws SystemException if a system exception occurred
439            */
440            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll()
441                    throws com.liferay.portal.kernel.exception.SystemException {
442                    return getPersistence().findAll();
443            }
444    
445            /**
446            * Returns a range of all the s c product versions.
447            *
448            * <p>
449            * 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.SCProductVersionModelImpl}. 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.
450            * </p>
451            *
452            * @param start the lower bound of the range of s c product versions
453            * @param end the upper bound of the range of s c product versions (not inclusive)
454            * @return the range of s c product versions
455            * @throws SystemException if a system exception occurred
456            */
457            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll(
458                    int start, int end)
459                    throws com.liferay.portal.kernel.exception.SystemException {
460                    return getPersistence().findAll(start, end);
461            }
462    
463            /**
464            * Returns an ordered range of all the s c product versions.
465            *
466            * <p>
467            * 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.SCProductVersionModelImpl}. 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.
468            * </p>
469            *
470            * @param start the lower bound of the range of s c product versions
471            * @param end the upper bound of the range of s c product versions (not inclusive)
472            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
473            * @return the ordered range of s c product versions
474            * @throws SystemException if a system exception occurred
475            */
476            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll(
477                    int start, int end,
478                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
479                    throws com.liferay.portal.kernel.exception.SystemException {
480                    return getPersistence().findAll(start, end, orderByComparator);
481            }
482    
483            /**
484            * Removes all the s c product versions from the database.
485            *
486            * @throws SystemException if a system exception occurred
487            */
488            public static void removeAll()
489                    throws com.liferay.portal.kernel.exception.SystemException {
490                    getPersistence().removeAll();
491            }
492    
493            /**
494            * Returns the number of s c product versions.
495            *
496            * @return the number of s c product versions
497            * @throws SystemException if a system exception occurred
498            */
499            public static int countAll()
500                    throws com.liferay.portal.kernel.exception.SystemException {
501                    return getPersistence().countAll();
502            }
503    
504            /**
505            * Returns all the s c framework versions associated with the s c product version.
506            *
507            * @param pk the primary key of the s c product version
508            * @return the s c framework versions associated with the s c product version
509            * @throws SystemException if a system exception occurred
510            */
511            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
512                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
513                    return getPersistence().getSCFrameworkVersions(pk);
514            }
515    
516            /**
517            * Returns a range of all the s c framework versions associated with the s c product version.
518            *
519            * <p>
520            * 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.SCProductVersionModelImpl}. 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.
521            * </p>
522            *
523            * @param pk the primary key of the s c product version
524            * @param start the lower bound of the range of s c product versions
525            * @param end the upper bound of the range of s c product versions (not inclusive)
526            * @return the range of s c framework versions associated with the s c product version
527            * @throws SystemException if a system exception occurred
528            */
529            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
530                    long pk, int start, int end)
531                    throws com.liferay.portal.kernel.exception.SystemException {
532                    return getPersistence().getSCFrameworkVersions(pk, start, end);
533            }
534    
535            /**
536            * Returns an ordered range of all the s c framework versions associated with the s c product version.
537            *
538            * <p>
539            * 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.SCProductVersionModelImpl}. 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.
540            * </p>
541            *
542            * @param pk the primary key of the s c product version
543            * @param start the lower bound of the range of s c product versions
544            * @param end the upper bound of the range of s c product versions (not inclusive)
545            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
546            * @return the ordered range of s c framework versions associated with the s c product version
547            * @throws SystemException if a system exception occurred
548            */
549            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
550                    long pk, int start, int end,
551                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
552                    throws com.liferay.portal.kernel.exception.SystemException {
553                    return getPersistence()
554                                       .getSCFrameworkVersions(pk, start, end, orderByComparator);
555            }
556    
557            /**
558            * Returns the number of s c framework versions associated with the s c product version.
559            *
560            * @param pk the primary key of the s c product version
561            * @return the number of s c framework versions associated with the s c product version
562            * @throws SystemException if a system exception occurred
563            */
564            public static int getSCFrameworkVersionsSize(long pk)
565                    throws com.liferay.portal.kernel.exception.SystemException {
566                    return getPersistence().getSCFrameworkVersionsSize(pk);
567            }
568    
569            /**
570            * Returns <code>true</code> if the s c framework version is associated with the s c product version.
571            *
572            * @param pk the primary key of the s c product version
573            * @param scFrameworkVersionPK the primary key of the s c framework version
574            * @return <code>true</code> if the s c framework version is associated with the s c product version; <code>false</code> otherwise
575            * @throws SystemException if a system exception occurred
576            */
577            public static boolean containsSCFrameworkVersion(long pk,
578                    long scFrameworkVersionPK)
579                    throws com.liferay.portal.kernel.exception.SystemException {
580                    return getPersistence()
581                                       .containsSCFrameworkVersion(pk, scFrameworkVersionPK);
582            }
583    
584            /**
585            * Returns <code>true</code> if the s c product version has any s c framework versions associated with it.
586            *
587            * @param pk the primary key of the s c product version to check for associations with s c framework versions
588            * @return <code>true</code> if the s c product version has any s c framework versions associated with it; <code>false</code> otherwise
589            * @throws SystemException if a system exception occurred
590            */
591            public static boolean containsSCFrameworkVersions(long pk)
592                    throws com.liferay.portal.kernel.exception.SystemException {
593                    return getPersistence().containsSCFrameworkVersions(pk);
594            }
595    
596            /**
597            * Adds an association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
598            *
599            * @param pk the primary key of the s c product version
600            * @param scFrameworkVersionPK the primary key of the s c framework version
601            * @throws SystemException if a system exception occurred
602            */
603            public static void addSCFrameworkVersion(long pk, long scFrameworkVersionPK)
604                    throws com.liferay.portal.kernel.exception.SystemException {
605                    getPersistence().addSCFrameworkVersion(pk, scFrameworkVersionPK);
606            }
607    
608            /**
609            * Adds an association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
610            *
611            * @param pk the primary key of the s c product version
612            * @param scFrameworkVersion the s c framework version
613            * @throws SystemException if a system exception occurred
614            */
615            public static void addSCFrameworkVersion(long pk,
616                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion)
617                    throws com.liferay.portal.kernel.exception.SystemException {
618                    getPersistence().addSCFrameworkVersion(pk, scFrameworkVersion);
619            }
620    
621            /**
622            * Adds an association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
623            *
624            * @param pk the primary key of the s c product version
625            * @param scFrameworkVersionPKs the primary keys of the s c framework versions
626            * @throws SystemException if a system exception occurred
627            */
628            public static void addSCFrameworkVersions(long pk,
629                    long[] scFrameworkVersionPKs)
630                    throws com.liferay.portal.kernel.exception.SystemException {
631                    getPersistence().addSCFrameworkVersions(pk, scFrameworkVersionPKs);
632            }
633    
634            /**
635            * Adds an association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
636            *
637            * @param pk the primary key of the s c product version
638            * @param scFrameworkVersions the s c framework versions
639            * @throws SystemException if a system exception occurred
640            */
641            public static void addSCFrameworkVersions(long pk,
642                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions)
643                    throws com.liferay.portal.kernel.exception.SystemException {
644                    getPersistence().addSCFrameworkVersions(pk, scFrameworkVersions);
645            }
646    
647            /**
648            * Clears all associations between the s c product version and its s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
649            *
650            * @param pk the primary key of the s c product version to clear the associated s c framework versions from
651            * @throws SystemException if a system exception occurred
652            */
653            public static void clearSCFrameworkVersions(long pk)
654                    throws com.liferay.portal.kernel.exception.SystemException {
655                    getPersistence().clearSCFrameworkVersions(pk);
656            }
657    
658            /**
659            * Removes the association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
660            *
661            * @param pk the primary key of the s c product version
662            * @param scFrameworkVersionPK the primary key of the s c framework version
663            * @throws SystemException if a system exception occurred
664            */
665            public static void removeSCFrameworkVersion(long pk,
666                    long scFrameworkVersionPK)
667                    throws com.liferay.portal.kernel.exception.SystemException {
668                    getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersionPK);
669            }
670    
671            /**
672            * Removes the association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
673            *
674            * @param pk the primary key of the s c product version
675            * @param scFrameworkVersion the s c framework version
676            * @throws SystemException if a system exception occurred
677            */
678            public static void removeSCFrameworkVersion(long pk,
679                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion)
680                    throws com.liferay.portal.kernel.exception.SystemException {
681                    getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersion);
682            }
683    
684            /**
685            * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
686            *
687            * @param pk the primary key of the s c product version
688            * @param scFrameworkVersionPKs the primary keys of the s c framework versions
689            * @throws SystemException if a system exception occurred
690            */
691            public static void removeSCFrameworkVersions(long pk,
692                    long[] scFrameworkVersionPKs)
693                    throws com.liferay.portal.kernel.exception.SystemException {
694                    getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersionPKs);
695            }
696    
697            /**
698            * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
699            *
700            * @param pk the primary key of the s c product version
701            * @param scFrameworkVersions the s c framework versions
702            * @throws SystemException if a system exception occurred
703            */
704            public static void removeSCFrameworkVersions(long pk,
705                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions)
706                    throws com.liferay.portal.kernel.exception.SystemException {
707                    getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersions);
708            }
709    
710            /**
711            * Sets the s c framework versions associated with the s c product version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
712            *
713            * @param pk the primary key of the s c product version
714            * @param scFrameworkVersionPKs the primary keys of the s c framework versions to be associated with the s c product version
715            * @throws SystemException if a system exception occurred
716            */
717            public static void setSCFrameworkVersions(long pk,
718                    long[] scFrameworkVersionPKs)
719                    throws com.liferay.portal.kernel.exception.SystemException {
720                    getPersistence().setSCFrameworkVersions(pk, scFrameworkVersionPKs);
721            }
722    
723            /**
724            * Sets the s c framework versions associated with the s c product version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
725            *
726            * @param pk the primary key of the s c product version
727            * @param scFrameworkVersions the s c framework versions to be associated with the s c product version
728            * @throws SystemException if a system exception occurred
729            */
730            public static void setSCFrameworkVersions(long pk,
731                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions)
732                    throws com.liferay.portal.kernel.exception.SystemException {
733                    getPersistence().setSCFrameworkVersions(pk, scFrameworkVersions);
734            }
735    
736            public static SCProductVersionPersistence getPersistence() {
737                    if (_persistence == null) {
738                            _persistence = (SCProductVersionPersistence)PortalBeanLocatorUtil.locate(SCProductVersionPersistence.class.getName());
739    
740                            ReferenceRegistry.registerReference(SCProductVersionUtil.class,
741                                    "_persistence");
742                    }
743    
744                    return _persistence;
745            }
746    
747            /**
748             * @deprecated As of 6.2.0
749             */
750            public void setPersistence(SCProductVersionPersistence persistence) {
751            }
752    
753            private static SCProductVersionPersistence _persistence;
754    }