001    /**
002     * Copyright (c) 2000-2011 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. 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            * Filters by the user's permissions and finds all the s c licenses where active = &#63;.
321            *
322            * @param active the active to search with
323            * @return the matching s c licenses that the user has permission to view
324            * @throws SystemException if a system exception occurred
325            */
326            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive(
327                    boolean active)
328                    throws com.liferay.portal.kernel.exception.SystemException {
329                    return getPersistence().filterFindByActive(active);
330            }
331    
332            /**
333            * Filters by the user's permissions and finds a range of all the s c licenses where active = &#63;.
334            *
335            * <p>
336            * 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.
337            * </p>
338            *
339            * @param active the active to search with
340            * @param start the lower bound of the range of s c licenses to return
341            * @param end the upper bound of the range of s c licenses to return (not inclusive)
342            * @return the range of matching s c licenses that the user has permission to view
343            * @throws SystemException if a system exception occurred
344            */
345            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive(
346                    boolean active, int start, int end)
347                    throws com.liferay.portal.kernel.exception.SystemException {
348                    return getPersistence().filterFindByActive(active, start, end);
349            }
350    
351            /**
352            * Filters by the user's permissions and finds an ordered range of all the s c licenses where active = &#63;.
353            *
354            * <p>
355            * 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.
356            * </p>
357            *
358            * @param active the active to search with
359            * @param start the lower bound of the range of s c licenses to return
360            * @param end the upper bound of the range of s c licenses to return (not inclusive)
361            * @param orderByComparator the comparator to order the results by
362            * @return the ordered range of matching s c licenses that the user has permission to view
363            * @throws SystemException if a system exception occurred
364            */
365            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive(
366                    boolean active, int start, int end,
367                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
368                    throws com.liferay.portal.kernel.exception.SystemException {
369                    return getPersistence()
370                                       .filterFindByActive(active, start, end, orderByComparator);
371            }
372    
373            /**
374            * Finds all the s c licenses where active = &#63; and recommended = &#63;.
375            *
376            * @param active the active to search with
377            * @param recommended the recommended to search with
378            * @return the matching s c licenses
379            * @throws SystemException if a system exception occurred
380            */
381            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
382                    boolean active, boolean recommended)
383                    throws com.liferay.portal.kernel.exception.SystemException {
384                    return getPersistence().findByA_R(active, recommended);
385            }
386    
387            /**
388            * Finds a range of all the s c licenses where active = &#63; and recommended = &#63;.
389            *
390            * <p>
391            * 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.
392            * </p>
393            *
394            * @param active the active to search with
395            * @param recommended the recommended to search with
396            * @param start the lower bound of the range of s c licenses to return
397            * @param end the upper bound of the range of s c licenses to return (not inclusive)
398            * @return the range of matching s c licenses
399            * @throws SystemException if a system exception occurred
400            */
401            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
402                    boolean active, boolean recommended, int start, int end)
403                    throws com.liferay.portal.kernel.exception.SystemException {
404                    return getPersistence().findByA_R(active, recommended, start, end);
405            }
406    
407            /**
408            * Finds an ordered range of all the s c licenses where active = &#63; and recommended = &#63;.
409            *
410            * <p>
411            * 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.
412            * </p>
413            *
414            * @param active the active to search with
415            * @param recommended the recommended to search with
416            * @param start the lower bound of the range of s c licenses to return
417            * @param end the upper bound of the range of s c licenses to return (not inclusive)
418            * @param orderByComparator the comparator to order the results by
419            * @return the ordered range of matching s c licenses
420            * @throws SystemException if a system exception occurred
421            */
422            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
423                    boolean active, boolean recommended, int start, int end,
424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
425                    throws com.liferay.portal.kernel.exception.SystemException {
426                    return getPersistence()
427                                       .findByA_R(active, recommended, start, end, orderByComparator);
428            }
429    
430            /**
431            * Finds the first s c license in the ordered set where active = &#63; and recommended = &#63;.
432            *
433            * <p>
434            * 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.
435            * </p>
436            *
437            * @param active the active to search with
438            * @param recommended the recommended to search with
439            * @param orderByComparator the comparator to order the set by
440            * @return the first matching s c license
441            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
442            * @throws SystemException if a system exception occurred
443            */
444            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_First(
445                    boolean active, boolean recommended,
446                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
447                    throws com.liferay.portal.kernel.exception.SystemException,
448                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
449                    return getPersistence()
450                                       .findByA_R_First(active, recommended, orderByComparator);
451            }
452    
453            /**
454            * Finds the last s c license in the ordered set where active = &#63; and recommended = &#63;.
455            *
456            * <p>
457            * 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.
458            * </p>
459            *
460            * @param active the active to search with
461            * @param recommended the recommended to search with
462            * @param orderByComparator the comparator to order the set by
463            * @return the last matching s c license
464            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
465            * @throws SystemException if a system exception occurred
466            */
467            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_Last(
468                    boolean active, boolean recommended,
469                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
470                    throws com.liferay.portal.kernel.exception.SystemException,
471                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
472                    return getPersistence()
473                                       .findByA_R_Last(active, recommended, orderByComparator);
474            }
475    
476            /**
477            * Finds the s c licenses before and after the current s c license in the ordered set where active = &#63; and recommended = &#63;.
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 licenseId the primary key of the current s c license
484            * @param active the active to search with
485            * @param recommended the recommended to search with
486            * @param orderByComparator the comparator to order the set by
487            * @return the previous, current, and next s c license
488            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
489            * @throws SystemException if a system exception occurred
490            */
491            public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByA_R_PrevAndNext(
492                    long licenseId, boolean active, boolean recommended,
493                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
494                    throws com.liferay.portal.kernel.exception.SystemException,
495                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
496                    return getPersistence()
497                                       .findByA_R_PrevAndNext(licenseId, active, recommended,
498                            orderByComparator);
499            }
500    
501            /**
502            * Filters by the user's permissions and finds all the s c licenses where active = &#63; and recommended = &#63;.
503            *
504            * @param active the active to search with
505            * @param recommended the recommended to search with
506            * @return the matching s c licenses that the user has permission to view
507            * @throws SystemException if a system exception occurred
508            */
509            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R(
510                    boolean active, boolean recommended)
511                    throws com.liferay.portal.kernel.exception.SystemException {
512                    return getPersistence().filterFindByA_R(active, recommended);
513            }
514    
515            /**
516            * Filters by the user's permissions and finds a range of all the s c licenses where active = &#63; and recommended = &#63;.
517            *
518            * <p>
519            * 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.
520            * </p>
521            *
522            * @param active the active to search with
523            * @param recommended the recommended to search with
524            * @param start the lower bound of the range of s c licenses to return
525            * @param end the upper bound of the range of s c licenses to return (not inclusive)
526            * @return the range of matching s c licenses that the user has permission to view
527            * @throws SystemException if a system exception occurred
528            */
529            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R(
530                    boolean active, boolean recommended, int start, int end)
531                    throws com.liferay.portal.kernel.exception.SystemException {
532                    return getPersistence().filterFindByA_R(active, recommended, start, end);
533            }
534    
535            /**
536            * Filters by the user's permissions and finds an ordered range of all the s c licenses where active = &#63; and recommended = &#63;.
537            *
538            * <p>
539            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
540            * </p>
541            *
542            * @param active the active to search with
543            * @param recommended the recommended to search with
544            * @param start the lower bound of the range of s c licenses to return
545            * @param end the upper bound of the range of s c licenses to return (not inclusive)
546            * @param orderByComparator the comparator to order the results by
547            * @return the ordered range of matching s c licenses that the user has permission to view
548            * @throws SystemException if a system exception occurred
549            */
550            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R(
551                    boolean active, boolean recommended, int start, int end,
552                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
553                    throws com.liferay.portal.kernel.exception.SystemException {
554                    return getPersistence()
555                                       .filterFindByA_R(active, recommended, start, end,
556                            orderByComparator);
557            }
558    
559            /**
560            * Finds all the s c licenses.
561            *
562            * @return the s c licenses
563            * @throws SystemException if a system exception occurred
564            */
565            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll()
566                    throws com.liferay.portal.kernel.exception.SystemException {
567                    return getPersistence().findAll();
568            }
569    
570            /**
571            * Finds a range of all the s c licenses.
572            *
573            * <p>
574            * 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.
575            * </p>
576            *
577            * @param start the lower bound of the range of s c licenses to return
578            * @param end the upper bound of the range of s c licenses to return (not inclusive)
579            * @return the range of s c licenses
580            * @throws SystemException if a system exception occurred
581            */
582            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll(
583                    int start, int end)
584                    throws com.liferay.portal.kernel.exception.SystemException {
585                    return getPersistence().findAll(start, end);
586            }
587    
588            /**
589            * Finds an ordered range of all the s c licenses.
590            *
591            * <p>
592            * 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.
593            * </p>
594            *
595            * @param start the lower bound of the range of s c licenses to return
596            * @param end the upper bound of the range of s c licenses to return (not inclusive)
597            * @param orderByComparator the comparator to order the results by
598            * @return the ordered range of s c licenses
599            * @throws SystemException if a system exception occurred
600            */
601            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll(
602                    int start, int end,
603                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
604                    throws com.liferay.portal.kernel.exception.SystemException {
605                    return getPersistence().findAll(start, end, orderByComparator);
606            }
607    
608            /**
609            * Removes all the s c licenses where active = &#63; from the database.
610            *
611            * @param active the active to search with
612            * @throws SystemException if a system exception occurred
613            */
614            public static void removeByActive(boolean active)
615                    throws com.liferay.portal.kernel.exception.SystemException {
616                    getPersistence().removeByActive(active);
617            }
618    
619            /**
620            * Removes all the s c licenses where active = &#63; and recommended = &#63; from the database.
621            *
622            * @param active the active to search with
623            * @param recommended the recommended to search with
624            * @throws SystemException if a system exception occurred
625            */
626            public static void removeByA_R(boolean active, boolean recommended)
627                    throws com.liferay.portal.kernel.exception.SystemException {
628                    getPersistence().removeByA_R(active, recommended);
629            }
630    
631            /**
632            * Removes all the s c licenses from the database.
633            *
634            * @throws SystemException if a system exception occurred
635            */
636            public static void removeAll()
637                    throws com.liferay.portal.kernel.exception.SystemException {
638                    getPersistence().removeAll();
639            }
640    
641            /**
642            * Counts all the s c licenses where active = &#63;.
643            *
644            * @param active the active to search with
645            * @return the number of matching s c licenses
646            * @throws SystemException if a system exception occurred
647            */
648            public static int countByActive(boolean active)
649                    throws com.liferay.portal.kernel.exception.SystemException {
650                    return getPersistence().countByActive(active);
651            }
652    
653            /**
654            * Filters by the user's permissions and counts all the s c licenses where active = &#63;.
655            *
656            * @param active the active to search with
657            * @return the number of matching s c licenses that the user has permission to view
658            * @throws SystemException if a system exception occurred
659            */
660            public static int filterCountByActive(boolean active)
661                    throws com.liferay.portal.kernel.exception.SystemException {
662                    return getPersistence().filterCountByActive(active);
663            }
664    
665            /**
666            * Counts all the s c licenses where active = &#63; and recommended = &#63;.
667            *
668            * @param active the active to search with
669            * @param recommended the recommended to search with
670            * @return the number of matching s c licenses
671            * @throws SystemException if a system exception occurred
672            */
673            public static int countByA_R(boolean active, boolean recommended)
674                    throws com.liferay.portal.kernel.exception.SystemException {
675                    return getPersistence().countByA_R(active, recommended);
676            }
677    
678            /**
679            * Filters by the user's permissions and counts all the s c licenses where active = &#63; and recommended = &#63;.
680            *
681            * @param active the active to search with
682            * @param recommended the recommended to search with
683            * @return the number of matching s c licenses that the user has permission to view
684            * @throws SystemException if a system exception occurred
685            */
686            public static int filterCountByA_R(boolean active, boolean recommended)
687                    throws com.liferay.portal.kernel.exception.SystemException {
688                    return getPersistence().filterCountByA_R(active, recommended);
689            }
690    
691            /**
692            * Counts all the s c licenses.
693            *
694            * @return the number of s c licenses
695            * @throws SystemException if a system exception occurred
696            */
697            public static int countAll()
698                    throws com.liferay.portal.kernel.exception.SystemException {
699                    return getPersistence().countAll();
700            }
701    
702            /**
703            * Gets all the s c product entries associated with the s c license.
704            *
705            * @param pk the primary key of the s c license to get the associated s c product entries for
706            * @return the s c product entries associated with the s c license
707            * @throws SystemException if a system exception occurred
708            */
709            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
710                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
711                    return getPersistence().getSCProductEntries(pk);
712            }
713    
714            /**
715            * Gets a range of all the s c product entries associated with the s c license.
716            *
717            * <p>
718            * 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.
719            * </p>
720            *
721            * @param pk the primary key of the s c license to get the associated s c product entries for
722            * @param start the lower bound of the range of s c licenses to return
723            * @param end the upper bound of the range of s c licenses to return (not inclusive)
724            * @return the range of s c product entries associated with the s c license
725            * @throws SystemException if a system exception occurred
726            */
727            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
728                    long pk, int start, int end)
729                    throws com.liferay.portal.kernel.exception.SystemException {
730                    return getPersistence().getSCProductEntries(pk, start, end);
731            }
732    
733            /**
734            * Gets an ordered range of all the s c product entries associated with the s c license.
735            *
736            * <p>
737            * 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.
738            * </p>
739            *
740            * @param pk the primary key of the s c license to get the associated s c product entries for
741            * @param start the lower bound of the range of s c licenses to return
742            * @param end the upper bound of the range of s c licenses to return (not inclusive)
743            * @param orderByComparator the comparator to order the results by
744            * @return the ordered range of s c product entries associated with the s c license
745            * @throws SystemException if a system exception occurred
746            */
747            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
748                    long pk, int start, int end,
749                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
750                    throws com.liferay.portal.kernel.exception.SystemException {
751                    return getPersistence()
752                                       .getSCProductEntries(pk, start, end, orderByComparator);
753            }
754    
755            /**
756            * Gets the number of s c product entries associated with the s c license.
757            *
758            * @param pk the primary key of the s c license to get the number of associated s c product entries for
759            * @return the number of s c product entries associated with the s c license
760            * @throws SystemException if a system exception occurred
761            */
762            public static int getSCProductEntriesSize(long pk)
763                    throws com.liferay.portal.kernel.exception.SystemException {
764                    return getPersistence().getSCProductEntriesSize(pk);
765            }
766    
767            /**
768            * Determines if the s c product entry is associated with the s c license.
769            *
770            * @param pk the primary key of the s c license
771            * @param scProductEntryPK the primary key of the s c product entry
772            * @return <code>true</code> if the s c product entry is associated with the s c license; <code>false</code> otherwise
773            * @throws SystemException if a system exception occurred
774            */
775            public static boolean containsSCProductEntry(long pk, long scProductEntryPK)
776                    throws com.liferay.portal.kernel.exception.SystemException {
777                    return getPersistence().containsSCProductEntry(pk, scProductEntryPK);
778            }
779    
780            /**
781            * Determines if the s c license has any s c product entries associated with it.
782            *
783            * @param pk the primary key of the s c license to check for associations with s c product entries
784            * @return <code>true</code> if the s c license has any s c product entries associated with it; <code>false</code> otherwise
785            * @throws SystemException if a system exception occurred
786            */
787            public static boolean containsSCProductEntries(long pk)
788                    throws com.liferay.portal.kernel.exception.SystemException {
789                    return getPersistence().containsSCProductEntries(pk);
790            }
791    
792            /**
793            * 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.
794            *
795            * @param pk the primary key of the s c license
796            * @param scProductEntryPK the primary key of the s c product entry
797            * @throws SystemException if a system exception occurred
798            */
799            public static void addSCProductEntry(long pk, long scProductEntryPK)
800                    throws com.liferay.portal.kernel.exception.SystemException {
801                    getPersistence().addSCProductEntry(pk, scProductEntryPK);
802            }
803    
804            /**
805            * 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.
806            *
807            * @param pk the primary key of the s c license
808            * @param scProductEntry the s c product entry
809            * @throws SystemException if a system exception occurred
810            */
811            public static void addSCProductEntry(long pk,
812                    com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry)
813                    throws com.liferay.portal.kernel.exception.SystemException {
814                    getPersistence().addSCProductEntry(pk, scProductEntry);
815            }
816    
817            /**
818            * 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.
819            *
820            * @param pk the primary key of the s c license
821            * @param scProductEntryPKs the primary keys of the s c product entries
822            * @throws SystemException if a system exception occurred
823            */
824            public static void addSCProductEntries(long pk, long[] scProductEntryPKs)
825                    throws com.liferay.portal.kernel.exception.SystemException {
826                    getPersistence().addSCProductEntries(pk, scProductEntryPKs);
827            }
828    
829            /**
830            * 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.
831            *
832            * @param pk the primary key of the s c license
833            * @param scProductEntries the s c product entries
834            * @throws SystemException if a system exception occurred
835            */
836            public static void addSCProductEntries(long pk,
837                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries)
838                    throws com.liferay.portal.kernel.exception.SystemException {
839                    getPersistence().addSCProductEntries(pk, scProductEntries);
840            }
841    
842            /**
843            * 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.
844            *
845            * @param pk the primary key of the s c license to clear the associated s c product entries from
846            * @throws SystemException if a system exception occurred
847            */
848            public static void clearSCProductEntries(long pk)
849                    throws com.liferay.portal.kernel.exception.SystemException {
850                    getPersistence().clearSCProductEntries(pk);
851            }
852    
853            /**
854            * 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.
855            *
856            * @param pk the primary key of the s c license
857            * @param scProductEntryPK the primary key of the s c product entry
858            * @throws SystemException if a system exception occurred
859            */
860            public static void removeSCProductEntry(long pk, long scProductEntryPK)
861                    throws com.liferay.portal.kernel.exception.SystemException {
862                    getPersistence().removeSCProductEntry(pk, scProductEntryPK);
863            }
864    
865            /**
866            * 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.
867            *
868            * @param pk the primary key of the s c license
869            * @param scProductEntry the s c product entry
870            * @throws SystemException if a system exception occurred
871            */
872            public static void removeSCProductEntry(long pk,
873                    com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry)
874                    throws com.liferay.portal.kernel.exception.SystemException {
875                    getPersistence().removeSCProductEntry(pk, scProductEntry);
876            }
877    
878            /**
879            * 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.
880            *
881            * @param pk the primary key of the s c license
882            * @param scProductEntryPKs the primary keys of the s c product entries
883            * @throws SystemException if a system exception occurred
884            */
885            public static void removeSCProductEntries(long pk, long[] scProductEntryPKs)
886                    throws com.liferay.portal.kernel.exception.SystemException {
887                    getPersistence().removeSCProductEntries(pk, scProductEntryPKs);
888            }
889    
890            /**
891            * 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.
892            *
893            * @param pk the primary key of the s c license
894            * @param scProductEntries the s c product entries
895            * @throws SystemException if a system exception occurred
896            */
897            public static void removeSCProductEntries(long pk,
898                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries)
899                    throws com.liferay.portal.kernel.exception.SystemException {
900                    getPersistence().removeSCProductEntries(pk, scProductEntries);
901            }
902    
903            /**
904            * 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.
905            *
906            * @param pk the primary key of the s c license to set the associations for
907            * @param scProductEntryPKs the primary keys of the s c product entries to be associated with the s c license
908            * @throws SystemException if a system exception occurred
909            */
910            public static void setSCProductEntries(long pk, long[] scProductEntryPKs)
911                    throws com.liferay.portal.kernel.exception.SystemException {
912                    getPersistence().setSCProductEntries(pk, scProductEntryPKs);
913            }
914    
915            /**
916            * 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.
917            *
918            * @param pk the primary key of the s c license to set the associations for
919            * @param scProductEntries the s c product entries to be associated with the s c license
920            * @throws SystemException if a system exception occurred
921            */
922            public static void setSCProductEntries(long pk,
923                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries)
924                    throws com.liferay.portal.kernel.exception.SystemException {
925                    getPersistence().setSCProductEntries(pk, scProductEntries);
926            }
927    
928            public static SCLicensePersistence getPersistence() {
929                    if (_persistence == null) {
930                            _persistence = (SCLicensePersistence)PortalBeanLocatorUtil.locate(SCLicensePersistence.class.getName());
931                    }
932    
933                    return _persistence;
934            }
935    
936            public void setPersistence(SCLicensePersistence persistence) {
937                    _persistence = persistence;
938            }
939    
940            private static SCLicensePersistence _persistence;
941    }