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