001    /**
002     * Copyright (c) 2000-2010 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.service.ServiceContext;
022    
023    import com.liferay.portlet.softwarecatalog.model.SCLicense;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the s c license service.
029     *
030     * <p>
031     * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class.
032     * </p>
033     *
034     * @author Brian Wing Shun Chan
035     * @see SCLicensePersistence
036     * @see SCLicensePersistenceImpl
037     * @generated
038     */
039    public class SCLicenseUtil {
040            /**
041             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
042             */
043            public static void clearCache() {
044                    getPersistence().clearCache();
045            }
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
049             */
050            public static void clearCache(SCLicense scLicense) {
051                    getPersistence().clearCache(scLicense);
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
056             */
057            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
058                    throws SystemException {
059                    return getPersistence().countWithDynamicQuery(dynamicQuery);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
064             */
065            public static List<SCLicense> findWithDynamicQuery(
066                    DynamicQuery dynamicQuery) throws SystemException {
067                    return getPersistence().findWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
072             */
073            public static List<SCLicense> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery, int start, int end)
075                    throws SystemException {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
081             */
082            public static List<SCLicense> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end,
084                    OrderByComparator orderByComparator) throws SystemException {
085                    return getPersistence()
086                                       .findWithDynamicQuery(dynamicQuery, start, end,
087                            orderByComparator);
088            }
089    
090            /**
091             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
092             */
093            public static SCLicense remove(SCLicense scLicense)
094                    throws SystemException {
095                    return getPersistence().remove(scLicense);
096            }
097    
098            /**
099             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
100             */
101            public static SCLicense update(SCLicense scLicense, boolean merge)
102                    throws SystemException {
103                    return getPersistence().update(scLicense, merge);
104            }
105    
106            /**
107             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
108             */
109            public static SCLicense update(SCLicense scLicense, boolean merge,
110                    ServiceContext serviceContext) throws SystemException {
111                    return getPersistence().update(scLicense, merge, serviceContext);
112            }
113    
114            /**
115            * Caches the s c license in the entity cache if it is enabled.
116            *
117            * @param scLicense the s c license to cache
118            */
119            public static void cacheResult(
120                    com.liferay.portlet.softwarecatalog.model.SCLicense scLicense) {
121                    getPersistence().cacheResult(scLicense);
122            }
123    
124            /**
125            * Caches the s c licenses in the entity cache if it is enabled.
126            *
127            * @param scLicenses the s c licenses to cache
128            */
129            public static void cacheResult(
130                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses) {
131                    getPersistence().cacheResult(scLicenses);
132            }
133    
134            /**
135            * Creates a new s c license with the primary key.
136            *
137            * @param licenseId the primary key for the new s c license
138            * @return the new s c license
139            */
140            public static com.liferay.portlet.softwarecatalog.model.SCLicense create(
141                    long licenseId) {
142                    return getPersistence().create(licenseId);
143            }
144    
145            /**
146            * Removes the s c license with the primary key from the database. Also notifies the appropriate model listeners.
147            *
148            * @param licenseId the primary key of the s c license to remove
149            * @return the s c license that was removed
150            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
151            * @throws SystemException if a system exception occurred
152            */
153            public static com.liferay.portlet.softwarecatalog.model.SCLicense remove(
154                    long licenseId)
155                    throws com.liferay.portal.kernel.exception.SystemException,
156                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
157                    return getPersistence().remove(licenseId);
158            }
159    
160            public static com.liferay.portlet.softwarecatalog.model.SCLicense updateImpl(
161                    com.liferay.portlet.softwarecatalog.model.SCLicense scLicense,
162                    boolean merge)
163                    throws com.liferay.portal.kernel.exception.SystemException {
164                    return getPersistence().updateImpl(scLicense, merge);
165            }
166    
167            /**
168            * Finds the s c license with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchLicenseException} if it could not be found.
169            *
170            * @param licenseId the primary key of the s c license to find
171            * @return the s c license
172            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByPrimaryKey(
176                    long licenseId)
177                    throws com.liferay.portal.kernel.exception.SystemException,
178                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
179                    return getPersistence().findByPrimaryKey(licenseId);
180            }
181    
182            /**
183            * Finds the s c license with the primary key or returns <code>null</code> if it could not be found.
184            *
185            * @param licenseId the primary key of the s c license to find
186            * @return the s c license, or <code>null</code> if a s c license with the primary key could not be found
187            * @throws SystemException if a system exception occurred
188            */
189            public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByPrimaryKey(
190                    long licenseId)
191                    throws com.liferay.portal.kernel.exception.SystemException {
192                    return getPersistence().fetchByPrimaryKey(licenseId);
193            }
194    
195            /**
196            * Finds all the s c licenses where active = &#63;.
197            *
198            * @param active the active to search with
199            * @return the matching s c licenses
200            * @throws SystemException if a system exception occurred
201            */
202            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive(
203                    boolean active)
204                    throws com.liferay.portal.kernel.exception.SystemException {
205                    return getPersistence().findByActive(active);
206            }
207    
208            /**
209            * Finds a range of all the s c licenses where active = &#63;.
210            *
211            * <p>
212            * 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.
213            * </p>
214            *
215            * @param active the active to search with
216            * @param start the lower bound of the range of s c licenses to return
217            * @param end the upper bound of the range of s c licenses to return (not inclusive)
218            * @return the range of matching s c licenses
219            * @throws SystemException if a system exception occurred
220            */
221            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive(
222                    boolean active, int start, int end)
223                    throws com.liferay.portal.kernel.exception.SystemException {
224                    return getPersistence().findByActive(active, start, end);
225            }
226    
227            /**
228            * Finds an ordered range of all the s c licenses where active = &#63;.
229            *
230            * <p>
231            * 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.
232            * </p>
233            *
234            * @param active the active to search with
235            * @param start the lower bound of the range of s c licenses to return
236            * @param end the upper bound of the range of s c licenses to return (not inclusive)
237            * @param orderByComparator the comparator to order the results by
238            * @return the ordered range of matching s c licenses
239            * @throws SystemException if a system exception occurred
240            */
241            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive(
242                    boolean active, int start, int end,
243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
244                    throws com.liferay.portal.kernel.exception.SystemException {
245                    return getPersistence()
246                                       .findByActive(active, start, end, orderByComparator);
247            }
248    
249            /**
250            * Finds the first s c license in the ordered set where active = &#63;.
251            *
252            * <p>
253            * 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.
254            * </p>
255            *
256            * @param active the active to search with
257            * @param orderByComparator the comparator to order the set by
258            * @return the first matching s c license
259            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
260            * @throws SystemException if a system exception occurred
261            */
262            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_First(
263                    boolean active,
264                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
265                    throws com.liferay.portal.kernel.exception.SystemException,
266                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
267                    return getPersistence().findByActive_First(active, orderByComparator);
268            }
269    
270            /**
271            * Finds the last s c license in the ordered set where active = &#63;.
272            *
273            * <p>
274            * 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.
275            * </p>
276            *
277            * @param active the active to search with
278            * @param orderByComparator the comparator to order the set by
279            * @return the last matching s c license
280            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
281            * @throws SystemException if a system exception occurred
282            */
283            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_Last(
284                    boolean active,
285                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
286                    throws com.liferay.portal.kernel.exception.SystemException,
287                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
288                    return getPersistence().findByActive_Last(active, orderByComparator);
289            }
290    
291            /**
292            * Finds the s c licenses before and after the current s c license in the ordered set where active = &#63;.
293            *
294            * <p>
295            * 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.
296            * </p>
297            *
298            * @param licenseId the primary key of the current s c license
299            * @param active the active to search with
300            * @param orderByComparator the comparator to order the set by
301            * @return the previous, current, and next s c license
302            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
303            * @throws SystemException if a system exception occurred
304            */
305            public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByActive_PrevAndNext(
306                    long licenseId, boolean active,
307                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
308                    throws com.liferay.portal.kernel.exception.SystemException,
309                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
310                    return getPersistence()
311                                       .findByActive_PrevAndNext(licenseId, active,
312                            orderByComparator);
313            }
314    
315            /**
316            * Finds all the s c licenses where active = &#63; and recommended = &#63;.
317            *
318            * @param active the active to search with
319            * @param recommended the recommended to search with
320            * @return the matching s c licenses
321            * @throws SystemException if a system exception occurred
322            */
323            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
324                    boolean active, boolean recommended)
325                    throws com.liferay.portal.kernel.exception.SystemException {
326                    return getPersistence().findByA_R(active, recommended);
327            }
328    
329            /**
330            * Finds a range of all the s c licenses where active = &#63; and recommended = &#63;.
331            *
332            * <p>
333            * 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.
334            * </p>
335            *
336            * @param active the active to search with
337            * @param recommended the recommended to search with
338            * @param start the lower bound of the range of s c licenses to return
339            * @param end the upper bound of the range of s c licenses to return (not inclusive)
340            * @return the range of matching s c licenses
341            * @throws SystemException if a system exception occurred
342            */
343            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
344                    boolean active, boolean recommended, int start, int end)
345                    throws com.liferay.portal.kernel.exception.SystemException {
346                    return getPersistence().findByA_R(active, recommended, start, end);
347            }
348    
349            /**
350            * Finds an ordered range of all the s c licenses where active = &#63; and recommended = &#63;.
351            *
352            * <p>
353            * 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.
354            * </p>
355            *
356            * @param active the active to search with
357            * @param recommended the recommended to search with
358            * @param start the lower bound of the range of s c licenses to return
359            * @param end the upper bound of the range of s c licenses to return (not inclusive)
360            * @param orderByComparator the comparator to order the results by
361            * @return the ordered range of matching s c licenses
362            * @throws SystemException if a system exception occurred
363            */
364            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
365                    boolean active, boolean recommended, int start, int end,
366                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
367                    throws com.liferay.portal.kernel.exception.SystemException {
368                    return getPersistence()
369                                       .findByA_R(active, recommended, start, end, orderByComparator);
370            }
371    
372            /**
373            * Finds the first s c license in the ordered set where active = &#63; and recommended = &#63;.
374            *
375            * <p>
376            * 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.
377            * </p>
378            *
379            * @param active the active to search with
380            * @param recommended the recommended to search with
381            * @param orderByComparator the comparator to order the set by
382            * @return the first matching s c license
383            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
384            * @throws SystemException if a system exception occurred
385            */
386            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_First(
387                    boolean active, boolean recommended,
388                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
389                    throws com.liferay.portal.kernel.exception.SystemException,
390                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
391                    return getPersistence()
392                                       .findByA_R_First(active, recommended, orderByComparator);
393            }
394    
395            /**
396            * Finds the last s c license in the ordered set where active = &#63; and recommended = &#63;.
397            *
398            * <p>
399            * 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.
400            * </p>
401            *
402            * @param active the active to search with
403            * @param recommended the recommended to search with
404            * @param orderByComparator the comparator to order the set by
405            * @return the last matching s c license
406            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
407            * @throws SystemException if a system exception occurred
408            */
409            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_Last(
410                    boolean active, boolean recommended,
411                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
412                    throws com.liferay.portal.kernel.exception.SystemException,
413                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
414                    return getPersistence()
415                                       .findByA_R_Last(active, recommended, orderByComparator);
416            }
417    
418            /**
419            * Finds the s c licenses before and after the current s c license in the ordered set where active = &#63; and recommended = &#63;.
420            *
421            * <p>
422            * 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.
423            * </p>
424            *
425            * @param licenseId the primary key of the current s c license
426            * @param active the active to search with
427            * @param recommended the recommended to search with
428            * @param orderByComparator the comparator to order the set by
429            * @return the previous, current, and next s c license
430            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
431            * @throws SystemException if a system exception occurred
432            */
433            public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByA_R_PrevAndNext(
434                    long licenseId, boolean active, boolean recommended,
435                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
436                    throws com.liferay.portal.kernel.exception.SystemException,
437                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
438                    return getPersistence()
439                                       .findByA_R_PrevAndNext(licenseId, active, recommended,
440                            orderByComparator);
441            }
442    
443            /**
444            * Finds all the s c licenses.
445            *
446            * @return the s c licenses
447            * @throws SystemException if a system exception occurred
448            */
449            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll()
450                    throws com.liferay.portal.kernel.exception.SystemException {
451                    return getPersistence().findAll();
452            }
453    
454            /**
455            * Finds a range of all the s c licenses.
456            *
457            * <p>
458            * 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.
459            * </p>
460            *
461            * @param start the lower bound of the range of s c licenses to return
462            * @param end the upper bound of the range of s c licenses to return (not inclusive)
463            * @return the range of s c licenses
464            * @throws SystemException if a system exception occurred
465            */
466            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll(
467                    int start, int end)
468                    throws com.liferay.portal.kernel.exception.SystemException {
469                    return getPersistence().findAll(start, end);
470            }
471    
472            /**
473            * Finds an ordered range of all the s c licenses.
474            *
475            * <p>
476            * 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.
477            * </p>
478            *
479            * @param start the lower bound of the range of s c licenses to return
480            * @param end the upper bound of the range of s c licenses to return (not inclusive)
481            * @param orderByComparator the comparator to order the results by
482            * @return the ordered range of s c licenses
483            * @throws SystemException if a system exception occurred
484            */
485            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll(
486                    int start, int end,
487                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
488                    throws com.liferay.portal.kernel.exception.SystemException {
489                    return getPersistence().findAll(start, end, orderByComparator);
490            }
491    
492            /**
493            * Removes all the s c licenses where active = &#63; from the database.
494            *
495            * @param active the active to search with
496            * @throws SystemException if a system exception occurred
497            */
498            public static void removeByActive(boolean active)
499                    throws com.liferay.portal.kernel.exception.SystemException {
500                    getPersistence().removeByActive(active);
501            }
502    
503            /**
504            * Removes all the s c licenses where active = &#63; and recommended = &#63; from the database.
505            *
506            * @param active the active to search with
507            * @param recommended the recommended to search with
508            * @throws SystemException if a system exception occurred
509            */
510            public static void removeByA_R(boolean active, boolean recommended)
511                    throws com.liferay.portal.kernel.exception.SystemException {
512                    getPersistence().removeByA_R(active, recommended);
513            }
514    
515            /**
516            * Removes all the s c licenses from the database.
517            *
518            * @throws SystemException if a system exception occurred
519            */
520            public static void removeAll()
521                    throws com.liferay.portal.kernel.exception.SystemException {
522                    getPersistence().removeAll();
523            }
524    
525            /**
526            * Counts all the s c licenses where active = &#63;.
527            *
528            * @param active the active to search with
529            * @return the number of matching s c licenses
530            * @throws SystemException if a system exception occurred
531            */
532            public static int countByActive(boolean active)
533                    throws com.liferay.portal.kernel.exception.SystemException {
534                    return getPersistence().countByActive(active);
535            }
536    
537            /**
538            * Counts all the s c licenses where active = &#63; and recommended = &#63;.
539            *
540            * @param active the active to search with
541            * @param recommended the recommended to search with
542            * @return the number of matching s c licenses
543            * @throws SystemException if a system exception occurred
544            */
545            public static int countByA_R(boolean active, boolean recommended)
546                    throws com.liferay.portal.kernel.exception.SystemException {
547                    return getPersistence().countByA_R(active, recommended);
548            }
549    
550            /**
551            * Counts all the s c licenses.
552            *
553            * @return the number of s c licenses
554            * @throws SystemException if a system exception occurred
555            */
556            public static int countAll()
557                    throws com.liferay.portal.kernel.exception.SystemException {
558                    return getPersistence().countAll();
559            }
560    
561            /**
562            * Gets all the s c product entries associated with the s c license.
563            *
564            * @param pk the primary key of the s c license to get the associated s c product entries for
565            * @return the s c product entries associated with the s c license
566            * @throws SystemException if a system exception occurred
567            */
568            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
569                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
570                    return getPersistence().getSCProductEntries(pk);
571            }
572    
573            /**
574            * Gets a range of all the s c product entries associated with the s c license.
575            *
576            * <p>
577            * 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.
578            * </p>
579            *
580            * @param pk the primary key of the s c license to get the associated s c product entries for
581            * @param start the lower bound of the range of s c licenses to return
582            * @param end the upper bound of the range of s c licenses to return (not inclusive)
583            * @return the range of s c product entries associated with the s c license
584            * @throws SystemException if a system exception occurred
585            */
586            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
587                    long pk, int start, int end)
588                    throws com.liferay.portal.kernel.exception.SystemException {
589                    return getPersistence().getSCProductEntries(pk, start, end);
590            }
591    
592            /**
593            * Gets an ordered range of all the s c product entries associated with the s c license.
594            *
595            * <p>
596            * 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.
597            * </p>
598            *
599            * @param pk the primary key of the s c license to get the associated s c product entries for
600            * @param start the lower bound of the range of s c licenses to return
601            * @param end the upper bound of the range of s c licenses to return (not inclusive)
602            * @param orderByComparator the comparator to order the results by
603            * @return the ordered range of s c product entries associated with the s c license
604            * @throws SystemException if a system exception occurred
605            */
606            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
607                    long pk, int start, int end,
608                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
609                    throws com.liferay.portal.kernel.exception.SystemException {
610                    return getPersistence()
611                                       .getSCProductEntries(pk, start, end, orderByComparator);
612            }
613    
614            /**
615            * Gets the number of s c product entries associated with the s c license.
616            *
617            * @param pk the primary key of the s c license to get the number of associated s c product entries for
618            * @return the number of s c product entries associated with the s c license
619            * @throws SystemException if a system exception occurred
620            */
621            public static int getSCProductEntriesSize(long pk)
622                    throws com.liferay.portal.kernel.exception.SystemException {
623                    return getPersistence().getSCProductEntriesSize(pk);
624            }
625    
626            /**
627            * Determines whether the s c product entry is associated with the s c license.
628            *
629            * @param pk the primary key of the s c license
630            * @param scProductEntryPK the primary key of the s c product entry
631            * @return whether the s c product entry is associated with the s c license
632            * @throws SystemException if a system exception occurred
633            */
634            public static boolean containsSCProductEntry(long pk, long scProductEntryPK)
635                    throws com.liferay.portal.kernel.exception.SystemException {
636                    return getPersistence().containsSCProductEntry(pk, scProductEntryPK);
637            }
638    
639            /**
640            * Determines whether the s c license has any s c product entries associated with it.
641            *
642            * @param pk the primary key of the s c license to check for associations with s c product entries
643            * @return whether the s c license has any s c product entries associated with it
644            * @throws SystemException if a system exception occurred
645            */
646            public static boolean containsSCProductEntries(long pk)
647                    throws com.liferay.portal.kernel.exception.SystemException {
648                    return getPersistence().containsSCProductEntries(pk);
649            }
650    
651            /**
652            * Adds an association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
653            *
654            * @param pk the primary key of the s c license
655            * @param scProductEntryPK the primary key of the s c product entry
656            * @throws SystemException if a system exception occurred
657            */
658            public static void addSCProductEntry(long pk, long scProductEntryPK)
659                    throws com.liferay.portal.kernel.exception.SystemException {
660                    getPersistence().addSCProductEntry(pk, scProductEntryPK);
661            }
662    
663            /**
664            * Adds an association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
665            *
666            * @param pk the primary key of the s c license
667            * @param scProductEntry the s c product entry
668            * @throws SystemException if a system exception occurred
669            */
670            public static void addSCProductEntry(long pk,
671                    com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry)
672                    throws com.liferay.portal.kernel.exception.SystemException {
673                    getPersistence().addSCProductEntry(pk, scProductEntry);
674            }
675    
676            /**
677            * Adds an association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
678            *
679            * @param pk the primary key of the s c license
680            * @param scProductEntryPKs the primary keys of the s c product entries
681            * @throws SystemException if a system exception occurred
682            */
683            public static void addSCProductEntries(long pk, long[] scProductEntryPKs)
684                    throws com.liferay.portal.kernel.exception.SystemException {
685                    getPersistence().addSCProductEntries(pk, scProductEntryPKs);
686            }
687    
688            /**
689            * Adds an association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
690            *
691            * @param pk the primary key of the s c license
692            * @param scProductEntries the s c product entries
693            * @throws SystemException if a system exception occurred
694            */
695            public static void addSCProductEntries(long pk,
696                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries)
697                    throws com.liferay.portal.kernel.exception.SystemException {
698                    getPersistence().addSCProductEntries(pk, scProductEntries);
699            }
700    
701            /**
702            * Clears all associations between the s c license and its s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
703            *
704            * @param pk the primary key of the s c license to clear the associated s c product entries from
705            * @throws SystemException if a system exception occurred
706            */
707            public static void clearSCProductEntries(long pk)
708                    throws com.liferay.portal.kernel.exception.SystemException {
709                    getPersistence().clearSCProductEntries(pk);
710            }
711    
712            /**
713            * Removes the association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
714            *
715            * @param pk the primary key of the s c license
716            * @param scProductEntryPK the primary key of the s c product entry
717            * @throws SystemException if a system exception occurred
718            */
719            public static void removeSCProductEntry(long pk, long scProductEntryPK)
720                    throws com.liferay.portal.kernel.exception.SystemException {
721                    getPersistence().removeSCProductEntry(pk, scProductEntryPK);
722            }
723    
724            /**
725            * Removes the association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
726            *
727            * @param pk the primary key of the s c license
728            * @param scProductEntry the s c product entry
729            * @throws SystemException if a system exception occurred
730            */
731            public static void removeSCProductEntry(long pk,
732                    com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry)
733                    throws com.liferay.portal.kernel.exception.SystemException {
734                    getPersistence().removeSCProductEntry(pk, scProductEntry);
735            }
736    
737            /**
738            * Removes the association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
739            *
740            * @param pk the primary key of the s c license
741            * @param scProductEntryPKs the primary keys of the s c product entries
742            * @throws SystemException if a system exception occurred
743            */
744            public static void removeSCProductEntries(long pk, long[] scProductEntryPKs)
745                    throws com.liferay.portal.kernel.exception.SystemException {
746                    getPersistence().removeSCProductEntries(pk, scProductEntryPKs);
747            }
748    
749            /**
750            * Removes the association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
751            *
752            * @param pk the primary key of the s c license
753            * @param scProductEntries the s c product entries
754            * @throws SystemException if a system exception occurred
755            */
756            public static void removeSCProductEntries(long pk,
757                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries)
758                    throws com.liferay.portal.kernel.exception.SystemException {
759                    getPersistence().removeSCProductEntries(pk, scProductEntries);
760            }
761    
762            /**
763            * Sets the s c product entries associated with the s c license, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
764            *
765            * @param pk the primary key of the s c license to set the associations for
766            * @param scProductEntryPKs the primary keys of the s c product entries to be associated with the s c license
767            * @throws SystemException if a system exception occurred
768            */
769            public static void setSCProductEntries(long pk, long[] scProductEntryPKs)
770                    throws com.liferay.portal.kernel.exception.SystemException {
771                    getPersistence().setSCProductEntries(pk, scProductEntryPKs);
772            }
773    
774            /**
775            * Sets the s c product entries associated with the s c license, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
776            *
777            * @param pk the primary key of the s c license to set the associations for
778            * @param scProductEntries the s c product entries to be associated with the s c license
779            * @throws SystemException if a system exception occurred
780            */
781            public static void setSCProductEntries(long pk,
782                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries)
783                    throws com.liferay.portal.kernel.exception.SystemException {
784                    getPersistence().setSCProductEntries(pk, scProductEntries);
785            }
786    
787            public static SCLicensePersistence getPersistence() {
788                    if (_persistence == null) {
789                            _persistence = (SCLicensePersistence)PortalBeanLocatorUtil.locate(SCLicensePersistence.class.getName());
790                    }
791    
792                    return _persistence;
793            }
794    
795            public void setPersistence(SCLicensePersistence persistence) {
796                    _persistence = persistence;
797            }
798    
799            private static SCLicensePersistence _persistence;
800    }