001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.softwarecatalog.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.softwarecatalog.model.SCLicense;
025    
026    import java.util.List;
027    
028    /**
029     * 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.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see SCLicensePersistence
037     * @see SCLicensePersistenceImpl
038     * @generated
039     */
040    public class SCLicenseUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(SCLicense scLicense) {
058                    getPersistence().clearCache(scLicense);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<SCLicense> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<SCLicense> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<SCLicense> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
099             */
100            public static SCLicense update(SCLicense scLicense, boolean merge)
101                    throws SystemException {
102                    return getPersistence().update(scLicense, merge);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
107             */
108            public static SCLicense update(SCLicense scLicense, boolean merge,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(scLicense, merge, serviceContext);
111            }
112    
113            /**
114            * Caches the s c license in the entity cache if it is enabled.
115            *
116            * @param scLicense the s c license
117            */
118            public static void cacheResult(
119                    com.liferay.portlet.softwarecatalog.model.SCLicense scLicense) {
120                    getPersistence().cacheResult(scLicense);
121            }
122    
123            /**
124            * Caches the s c licenses in the entity cache if it is enabled.
125            *
126            * @param scLicenses the s c licenses
127            */
128            public static void cacheResult(
129                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses) {
130                    getPersistence().cacheResult(scLicenses);
131            }
132    
133            /**
134            * Creates a new s c license with the primary key. Does not add the s c license to the database.
135            *
136            * @param licenseId the primary key for the new s c license
137            * @return the new s c license
138            */
139            public static com.liferay.portlet.softwarecatalog.model.SCLicense create(
140                    long licenseId) {
141                    return getPersistence().create(licenseId);
142            }
143    
144            /**
145            * Removes the s c license with the primary key from the database. Also notifies the appropriate model listeners.
146            *
147            * @param licenseId the primary key of the s c license
148            * @return the s c license that was removed
149            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
150            * @throws SystemException if a system exception occurred
151            */
152            public static com.liferay.portlet.softwarecatalog.model.SCLicense remove(
153                    long licenseId)
154                    throws com.liferay.portal.kernel.exception.SystemException,
155                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
156                    return getPersistence().remove(licenseId);
157            }
158    
159            public static com.liferay.portlet.softwarecatalog.model.SCLicense updateImpl(
160                    com.liferay.portlet.softwarecatalog.model.SCLicense scLicense,
161                    boolean merge)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().updateImpl(scLicense, merge);
164            }
165    
166            /**
167            * Returns the s c license with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchLicenseException} if it could not be found.
168            *
169            * @param licenseId the primary key of the s c license
170            * @return the s c license
171            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
172            * @throws SystemException if a system exception occurred
173            */
174            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByPrimaryKey(
175                    long licenseId)
176                    throws com.liferay.portal.kernel.exception.SystemException,
177                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
178                    return getPersistence().findByPrimaryKey(licenseId);
179            }
180    
181            /**
182            * Returns the s c license with the primary key or returns <code>null</code> if it could not be found.
183            *
184            * @param licenseId the primary key of the s c license
185            * @return the s c license, or <code>null</code> if a s c license with the primary key could not be found
186            * @throws SystemException if a system exception occurred
187            */
188            public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByPrimaryKey(
189                    long licenseId)
190                    throws com.liferay.portal.kernel.exception.SystemException {
191                    return getPersistence().fetchByPrimaryKey(licenseId);
192            }
193    
194            /**
195            * Returns all the s c licenses where active = &#63;.
196            *
197            * @param active the active
198            * @return the matching s c licenses
199            * @throws SystemException if a system exception occurred
200            */
201            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive(
202                    boolean active)
203                    throws com.liferay.portal.kernel.exception.SystemException {
204                    return getPersistence().findByActive(active);
205            }
206    
207            /**
208            * Returns a range of all the s c licenses where active = &#63;.
209            *
210            * <p>
211            * 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.
212            * </p>
213            *
214            * @param active the active
215            * @param start the lower bound of the range of s c licenses
216            * @param end the upper bound of the range of s c licenses (not inclusive)
217            * @return the range of matching s c licenses
218            * @throws SystemException if a system exception occurred
219            */
220            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive(
221                    boolean active, int start, int end)
222                    throws com.liferay.portal.kernel.exception.SystemException {
223                    return getPersistence().findByActive(active, start, end);
224            }
225    
226            /**
227            * Returns an ordered range of all the s c licenses where active = &#63;.
228            *
229            * <p>
230            * 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.
231            * </p>
232            *
233            * @param active the active
234            * @param start the lower bound of the range of s c licenses
235            * @param end the upper bound of the range of s c licenses (not inclusive)
236            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
237            * @return the ordered range of matching s c licenses
238            * @throws SystemException if a system exception occurred
239            */
240            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive(
241                    boolean active, int start, int end,
242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
243                    throws com.liferay.portal.kernel.exception.SystemException {
244                    return getPersistence()
245                                       .findByActive(active, start, end, orderByComparator);
246            }
247    
248            /**
249            * Returns the first s c license in the ordered set where active = &#63;.
250            *
251            * @param active the active
252            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
253            * @return the first matching s c license
254            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
255            * @throws SystemException if a system exception occurred
256            */
257            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_First(
258                    boolean active,
259                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
260                    throws com.liferay.portal.kernel.exception.SystemException,
261                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
262                    return getPersistence().findByActive_First(active, orderByComparator);
263            }
264    
265            /**
266            * Returns the first s c license in the ordered set where active = &#63;.
267            *
268            * @param active the active
269            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
270            * @return the first matching s c license, or <code>null</code> if a matching s c license could not be found
271            * @throws SystemException if a system exception occurred
272            */
273            public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByActive_First(
274                    boolean active,
275                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
276                    throws com.liferay.portal.kernel.exception.SystemException {
277                    return getPersistence().fetchByActive_First(active, orderByComparator);
278            }
279    
280            /**
281            * Returns the last s c license in the ordered set where active = &#63;.
282            *
283            * @param active the active
284            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
285            * @return the last matching s c license
286            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
287            * @throws SystemException if a system exception occurred
288            */
289            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_Last(
290                    boolean active,
291                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
292                    throws com.liferay.portal.kernel.exception.SystemException,
293                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
294                    return getPersistence().findByActive_Last(active, orderByComparator);
295            }
296    
297            /**
298            * Returns the last s c license in the ordered set where active = &#63;.
299            *
300            * @param active the active
301            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
302            * @return the last matching s c license, or <code>null</code> if a matching s c license could not be found
303            * @throws SystemException if a system exception occurred
304            */
305            public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByActive_Last(
306                    boolean active,
307                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
308                    throws com.liferay.portal.kernel.exception.SystemException {
309                    return getPersistence().fetchByActive_Last(active, orderByComparator);
310            }
311    
312            /**
313            * Returns the s c licenses before and after the current s c license in the ordered set where active = &#63;.
314            *
315            * @param licenseId the primary key of the current s c license
316            * @param active the active
317            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
318            * @return the previous, current, and next s c license
319            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
320            * @throws SystemException if a system exception occurred
321            */
322            public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByActive_PrevAndNext(
323                    long licenseId, boolean active,
324                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
325                    throws com.liferay.portal.kernel.exception.SystemException,
326                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
327                    return getPersistence()
328                                       .findByActive_PrevAndNext(licenseId, active,
329                            orderByComparator);
330            }
331    
332            /**
333            * Returns all the s c licenses that the user has permission to view where active = &#63;.
334            *
335            * @param active the active
336            * @return the matching s c licenses that the user has permission to view
337            * @throws SystemException if a system exception occurred
338            */
339            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive(
340                    boolean active)
341                    throws com.liferay.portal.kernel.exception.SystemException {
342                    return getPersistence().filterFindByActive(active);
343            }
344    
345            /**
346            * Returns a range of all the s c licenses that the user has permission to view where active = &#63;.
347            *
348            * <p>
349            * 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.
350            * </p>
351            *
352            * @param active the active
353            * @param start the lower bound of the range of s c licenses
354            * @param end the upper bound of the range of s c licenses (not inclusive)
355            * @return the range of matching s c licenses that the user has permission to view
356            * @throws SystemException if a system exception occurred
357            */
358            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive(
359                    boolean active, int start, int end)
360                    throws com.liferay.portal.kernel.exception.SystemException {
361                    return getPersistence().filterFindByActive(active, start, end);
362            }
363    
364            /**
365            * Returns an ordered range of all the s c licenses that the user has permissions to view where active = &#63;.
366            *
367            * <p>
368            * 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.
369            * </p>
370            *
371            * @param active the active
372            * @param start the lower bound of the range of s c licenses
373            * @param end the upper bound of the range of s c licenses (not inclusive)
374            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
375            * @return the ordered range of matching s c licenses that the user has permission to view
376            * @throws SystemException if a system exception occurred
377            */
378            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive(
379                    boolean active, int start, int end,
380                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
381                    throws com.liferay.portal.kernel.exception.SystemException {
382                    return getPersistence()
383                                       .filterFindByActive(active, start, end, orderByComparator);
384            }
385    
386            /**
387            * Returns the s c licenses before and after the current s c license in the ordered set of s c licenses that the user has permission to view where active = &#63;.
388            *
389            * @param licenseId the primary key of the current s c license
390            * @param active the active
391            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
392            * @return the previous, current, and next s c license
393            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
394            * @throws SystemException if a system exception occurred
395            */
396            public static com.liferay.portlet.softwarecatalog.model.SCLicense[] filterFindByActive_PrevAndNext(
397                    long licenseId, boolean active,
398                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
399                    throws com.liferay.portal.kernel.exception.SystemException,
400                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
401                    return getPersistence()
402                                       .filterFindByActive_PrevAndNext(licenseId, active,
403                            orderByComparator);
404            }
405    
406            /**
407            * Returns all the s c licenses where active = &#63; and recommended = &#63;.
408            *
409            * @param active the active
410            * @param recommended the recommended
411            * @return the matching s c licenses
412            * @throws SystemException if a system exception occurred
413            */
414            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
415                    boolean active, boolean recommended)
416                    throws com.liferay.portal.kernel.exception.SystemException {
417                    return getPersistence().findByA_R(active, recommended);
418            }
419    
420            /**
421            * Returns a range of all the s c licenses where active = &#63; and recommended = &#63;.
422            *
423            * <p>
424            * 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.
425            * </p>
426            *
427            * @param active the active
428            * @param recommended the recommended
429            * @param start the lower bound of the range of s c licenses
430            * @param end the upper bound of the range of s c licenses (not inclusive)
431            * @return the range of matching s c licenses
432            * @throws SystemException if a system exception occurred
433            */
434            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
435                    boolean active, boolean recommended, int start, int end)
436                    throws com.liferay.portal.kernel.exception.SystemException {
437                    return getPersistence().findByA_R(active, recommended, start, end);
438            }
439    
440            /**
441            * Returns an ordered range of all the s c licenses where active = &#63; and recommended = &#63;.
442            *
443            * <p>
444            * 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.
445            * </p>
446            *
447            * @param active the active
448            * @param recommended the recommended
449            * @param start the lower bound of the range of s c licenses
450            * @param end the upper bound of the range of s c licenses (not inclusive)
451            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
452            * @return the ordered range of matching s c licenses
453            * @throws SystemException if a system exception occurred
454            */
455            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
456                    boolean active, boolean recommended, int start, int end,
457                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
458                    throws com.liferay.portal.kernel.exception.SystemException {
459                    return getPersistence()
460                                       .findByA_R(active, recommended, start, end, orderByComparator);
461            }
462    
463            /**
464            * Returns the first s c license in the ordered set where active = &#63; and recommended = &#63;.
465            *
466            * @param active the active
467            * @param recommended the recommended
468            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
469            * @return the first matching s c license
470            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
471            * @throws SystemException if a system exception occurred
472            */
473            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_First(
474                    boolean active, boolean recommended,
475                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
476                    throws com.liferay.portal.kernel.exception.SystemException,
477                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
478                    return getPersistence()
479                                       .findByA_R_First(active, recommended, orderByComparator);
480            }
481    
482            /**
483            * Returns the first s c license in the ordered set where active = &#63; and recommended = &#63;.
484            *
485            * @param active the active
486            * @param recommended the recommended
487            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
488            * @return the first matching s c license, or <code>null</code> if a matching s c license could not be found
489            * @throws SystemException if a system exception occurred
490            */
491            public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByA_R_First(
492                    boolean active, boolean recommended,
493                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
494                    throws com.liferay.portal.kernel.exception.SystemException {
495                    return getPersistence()
496                                       .fetchByA_R_First(active, recommended, orderByComparator);
497            }
498    
499            /**
500            * Returns the last s c license in the ordered set where active = &#63; and recommended = &#63;.
501            *
502            * @param active the active
503            * @param recommended the recommended
504            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
505            * @return the last matching s c license
506            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
507            * @throws SystemException if a system exception occurred
508            */
509            public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_Last(
510                    boolean active, boolean recommended,
511                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
512                    throws com.liferay.portal.kernel.exception.SystemException,
513                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
514                    return getPersistence()
515                                       .findByA_R_Last(active, recommended, orderByComparator);
516            }
517    
518            /**
519            * Returns the last s c license in the ordered set where active = &#63; and recommended = &#63;.
520            *
521            * @param active the active
522            * @param recommended the recommended
523            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
524            * @return the last matching s c license, or <code>null</code> if a matching s c license could not be found
525            * @throws SystemException if a system exception occurred
526            */
527            public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByA_R_Last(
528                    boolean active, boolean recommended,
529                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
530                    throws com.liferay.portal.kernel.exception.SystemException {
531                    return getPersistence()
532                                       .fetchByA_R_Last(active, recommended, orderByComparator);
533            }
534    
535            /**
536            * Returns the s c licenses before and after the current s c license in the ordered set where active = &#63; and recommended = &#63;.
537            *
538            * @param licenseId the primary key of the current s c license
539            * @param active the active
540            * @param recommended the recommended
541            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
542            * @return the previous, current, and next s c license
543            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
544            * @throws SystemException if a system exception occurred
545            */
546            public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByA_R_PrevAndNext(
547                    long licenseId, boolean active, boolean recommended,
548                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
549                    throws com.liferay.portal.kernel.exception.SystemException,
550                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
551                    return getPersistence()
552                                       .findByA_R_PrevAndNext(licenseId, active, recommended,
553                            orderByComparator);
554            }
555    
556            /**
557            * Returns all the s c licenses that the user has permission to view where active = &#63; and recommended = &#63;.
558            *
559            * @param active the active
560            * @param recommended the recommended
561            * @return the matching s c licenses that the user has permission to view
562            * @throws SystemException if a system exception occurred
563            */
564            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R(
565                    boolean active, boolean recommended)
566                    throws com.liferay.portal.kernel.exception.SystemException {
567                    return getPersistence().filterFindByA_R(active, recommended);
568            }
569    
570            /**
571            * Returns a range of all the s c licenses that the user has permission to view where active = &#63; and recommended = &#63;.
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 active the active
578            * @param recommended the recommended
579            * @param start the lower bound of the range of s c licenses
580            * @param end the upper bound of the range of s c licenses (not inclusive)
581            * @return the range of matching s c licenses that the user has permission to view
582            * @throws SystemException if a system exception occurred
583            */
584            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R(
585                    boolean active, boolean recommended, int start, int end)
586                    throws com.liferay.portal.kernel.exception.SystemException {
587                    return getPersistence().filterFindByA_R(active, recommended, start, end);
588            }
589    
590            /**
591            * Returns an ordered range of all the s c licenses that the user has permissions to view where active = &#63; and recommended = &#63;.
592            *
593            * <p>
594            * 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.
595            * </p>
596            *
597            * @param active the active
598            * @param recommended the recommended
599            * @param start the lower bound of the range of s c licenses
600            * @param end the upper bound of the range of s c licenses (not inclusive)
601            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
602            * @return the ordered range of matching s c licenses that the user has permission to view
603            * @throws SystemException if a system exception occurred
604            */
605            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R(
606                    boolean active, boolean recommended, int start, int end,
607                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
608                    throws com.liferay.portal.kernel.exception.SystemException {
609                    return getPersistence()
610                                       .filterFindByA_R(active, recommended, start, end,
611                            orderByComparator);
612            }
613    
614            /**
615            * Returns the s c licenses before and after the current s c license in the ordered set of s c licenses that the user has permission to view where active = &#63; and recommended = &#63;.
616            *
617            * @param licenseId the primary key of the current s c license
618            * @param active the active
619            * @param recommended the recommended
620            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
621            * @return the previous, current, and next s c license
622            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
623            * @throws SystemException if a system exception occurred
624            */
625            public static com.liferay.portlet.softwarecatalog.model.SCLicense[] filterFindByA_R_PrevAndNext(
626                    long licenseId, boolean active, boolean recommended,
627                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
628                    throws com.liferay.portal.kernel.exception.SystemException,
629                            com.liferay.portlet.softwarecatalog.NoSuchLicenseException {
630                    return getPersistence()
631                                       .filterFindByA_R_PrevAndNext(licenseId, active, recommended,
632                            orderByComparator);
633            }
634    
635            /**
636            * Returns all the s c licenses.
637            *
638            * @return the s c licenses
639            * @throws SystemException if a system exception occurred
640            */
641            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll()
642                    throws com.liferay.portal.kernel.exception.SystemException {
643                    return getPersistence().findAll();
644            }
645    
646            /**
647            * Returns a range of all the s c licenses.
648            *
649            * <p>
650            * 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.
651            * </p>
652            *
653            * @param start the lower bound of the range of s c licenses
654            * @param end the upper bound of the range of s c licenses (not inclusive)
655            * @return the range of s c licenses
656            * @throws SystemException if a system exception occurred
657            */
658            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll(
659                    int start, int end)
660                    throws com.liferay.portal.kernel.exception.SystemException {
661                    return getPersistence().findAll(start, end);
662            }
663    
664            /**
665            * Returns an ordered range of all the s c licenses.
666            *
667            * <p>
668            * 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.
669            * </p>
670            *
671            * @param start the lower bound of the range of s c licenses
672            * @param end the upper bound of the range of s c licenses (not inclusive)
673            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
674            * @return the ordered range of s c licenses
675            * @throws SystemException if a system exception occurred
676            */
677            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll(
678                    int start, int end,
679                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
680                    throws com.liferay.portal.kernel.exception.SystemException {
681                    return getPersistence().findAll(start, end, orderByComparator);
682            }
683    
684            /**
685            * Removes all the s c licenses where active = &#63; from the database.
686            *
687            * @param active the active
688            * @throws SystemException if a system exception occurred
689            */
690            public static void removeByActive(boolean active)
691                    throws com.liferay.portal.kernel.exception.SystemException {
692                    getPersistence().removeByActive(active);
693            }
694    
695            /**
696            * Removes all the s c licenses where active = &#63; and recommended = &#63; from the database.
697            *
698            * @param active the active
699            * @param recommended the recommended
700            * @throws SystemException if a system exception occurred
701            */
702            public static void removeByA_R(boolean active, boolean recommended)
703                    throws com.liferay.portal.kernel.exception.SystemException {
704                    getPersistence().removeByA_R(active, recommended);
705            }
706    
707            /**
708            * Removes all the s c licenses from the database.
709            *
710            * @throws SystemException if a system exception occurred
711            */
712            public static void removeAll()
713                    throws com.liferay.portal.kernel.exception.SystemException {
714                    getPersistence().removeAll();
715            }
716    
717            /**
718            * Returns the number of s c licenses where active = &#63;.
719            *
720            * @param active the active
721            * @return the number of matching s c licenses
722            * @throws SystemException if a system exception occurred
723            */
724            public static int countByActive(boolean active)
725                    throws com.liferay.portal.kernel.exception.SystemException {
726                    return getPersistence().countByActive(active);
727            }
728    
729            /**
730            * Returns the number of s c licenses that the user has permission to view where active = &#63;.
731            *
732            * @param active the active
733            * @return the number of matching s c licenses that the user has permission to view
734            * @throws SystemException if a system exception occurred
735            */
736            public static int filterCountByActive(boolean active)
737                    throws com.liferay.portal.kernel.exception.SystemException {
738                    return getPersistence().filterCountByActive(active);
739            }
740    
741            /**
742            * Returns the number of s c licenses where active = &#63; and recommended = &#63;.
743            *
744            * @param active the active
745            * @param recommended the recommended
746            * @return the number of matching s c licenses
747            * @throws SystemException if a system exception occurred
748            */
749            public static int countByA_R(boolean active, boolean recommended)
750                    throws com.liferay.portal.kernel.exception.SystemException {
751                    return getPersistence().countByA_R(active, recommended);
752            }
753    
754            /**
755            * Returns the number of s c licenses that the user has permission to view where active = &#63; and recommended = &#63;.
756            *
757            * @param active the active
758            * @param recommended the recommended
759            * @return the number of matching s c licenses that the user has permission to view
760            * @throws SystemException if a system exception occurred
761            */
762            public static int filterCountByA_R(boolean active, boolean recommended)
763                    throws com.liferay.portal.kernel.exception.SystemException {
764                    return getPersistence().filterCountByA_R(active, recommended);
765            }
766    
767            /**
768            * Returns the number of s c licenses.
769            *
770            * @return the number of s c licenses
771            * @throws SystemException if a system exception occurred
772            */
773            public static int countAll()
774                    throws com.liferay.portal.kernel.exception.SystemException {
775                    return getPersistence().countAll();
776            }
777    
778            /**
779            * Returns all the s c product entries associated with the s c license.
780            *
781            * @param pk the primary key of the s c license
782            * @return the s c product entries associated with the s c license
783            * @throws SystemException if a system exception occurred
784            */
785            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
786                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
787                    return getPersistence().getSCProductEntries(pk);
788            }
789    
790            /**
791            * Returns a range of all the s c product entries associated with the s c license.
792            *
793            * <p>
794            * 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.
795            * </p>
796            *
797            * @param pk the primary key of the s c license
798            * @param start the lower bound of the range of s c licenses
799            * @param end the upper bound of the range of s c licenses (not inclusive)
800            * @return the range of s c product entries associated with the s c license
801            * @throws SystemException if a system exception occurred
802            */
803            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
804                    long pk, int start, int end)
805                    throws com.liferay.portal.kernel.exception.SystemException {
806                    return getPersistence().getSCProductEntries(pk, start, end);
807            }
808    
809            /**
810            * Returns an ordered range of all the s c product entries associated with the s c license.
811            *
812            * <p>
813            * 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.
814            * </p>
815            *
816            * @param pk the primary key of the s c license
817            * @param start the lower bound of the range of s c licenses
818            * @param end the upper bound of the range of s c licenses (not inclusive)
819            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
820            * @return the ordered range of s c product entries associated with the s c license
821            * @throws SystemException if a system exception occurred
822            */
823            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
824                    long pk, int start, int end,
825                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
826                    throws com.liferay.portal.kernel.exception.SystemException {
827                    return getPersistence()
828                                       .getSCProductEntries(pk, start, end, orderByComparator);
829            }
830    
831            /**
832            * Returns the number of s c product entries associated with the s c license.
833            *
834            * @param pk the primary key of the s c license
835            * @return the number of s c product entries associated with the s c license
836            * @throws SystemException if a system exception occurred
837            */
838            public static int getSCProductEntriesSize(long pk)
839                    throws com.liferay.portal.kernel.exception.SystemException {
840                    return getPersistence().getSCProductEntriesSize(pk);
841            }
842    
843            /**
844            * Returns <code>true</code> if the s c product entry is associated with the s c license.
845            *
846            * @param pk the primary key of the s c license
847            * @param scProductEntryPK the primary key of the s c product entry
848            * @return <code>true</code> if the s c product entry is associated with the s c license; <code>false</code> otherwise
849            * @throws SystemException if a system exception occurred
850            */
851            public static boolean containsSCProductEntry(long pk, long scProductEntryPK)
852                    throws com.liferay.portal.kernel.exception.SystemException {
853                    return getPersistence().containsSCProductEntry(pk, scProductEntryPK);
854            }
855    
856            /**
857            * Returns <code>true</code> if the s c license has any s c product entries associated with it.
858            *
859            * @param pk the primary key of the s c license to check for associations with s c product entries
860            * @return <code>true</code> if the s c license has any s c product entries associated with it; <code>false</code> otherwise
861            * @throws SystemException if a system exception occurred
862            */
863            public static boolean containsSCProductEntries(long pk)
864                    throws com.liferay.portal.kernel.exception.SystemException {
865                    return getPersistence().containsSCProductEntries(pk);
866            }
867    
868            /**
869            * 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.
870            *
871            * @param pk the primary key of the s c license
872            * @param scProductEntryPK the primary key of the s c product entry
873            * @throws SystemException if a system exception occurred
874            */
875            public static void addSCProductEntry(long pk, long scProductEntryPK)
876                    throws com.liferay.portal.kernel.exception.SystemException {
877                    getPersistence().addSCProductEntry(pk, scProductEntryPK);
878            }
879    
880            /**
881            * 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.
882            *
883            * @param pk the primary key of the s c license
884            * @param scProductEntry the s c product entry
885            * @throws SystemException if a system exception occurred
886            */
887            public static void addSCProductEntry(long pk,
888                    com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry)
889                    throws com.liferay.portal.kernel.exception.SystemException {
890                    getPersistence().addSCProductEntry(pk, scProductEntry);
891            }
892    
893            /**
894            * 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.
895            *
896            * @param pk the primary key of the s c license
897            * @param scProductEntryPKs the primary keys of the s c product entries
898            * @throws SystemException if a system exception occurred
899            */
900            public static void addSCProductEntries(long pk, long[] scProductEntryPKs)
901                    throws com.liferay.portal.kernel.exception.SystemException {
902                    getPersistence().addSCProductEntries(pk, scProductEntryPKs);
903            }
904    
905            /**
906            * 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.
907            *
908            * @param pk the primary key of the s c license
909            * @param scProductEntries the s c product entries
910            * @throws SystemException if a system exception occurred
911            */
912            public static void addSCProductEntries(long pk,
913                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries)
914                    throws com.liferay.portal.kernel.exception.SystemException {
915                    getPersistence().addSCProductEntries(pk, scProductEntries);
916            }
917    
918            /**
919            * 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.
920            *
921            * @param pk the primary key of the s c license to clear the associated s c product entries from
922            * @throws SystemException if a system exception occurred
923            */
924            public static void clearSCProductEntries(long pk)
925                    throws com.liferay.portal.kernel.exception.SystemException {
926                    getPersistence().clearSCProductEntries(pk);
927            }
928    
929            /**
930            * 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.
931            *
932            * @param pk the primary key of the s c license
933            * @param scProductEntryPK the primary key of the s c product entry
934            * @throws SystemException if a system exception occurred
935            */
936            public static void removeSCProductEntry(long pk, long scProductEntryPK)
937                    throws com.liferay.portal.kernel.exception.SystemException {
938                    getPersistence().removeSCProductEntry(pk, scProductEntryPK);
939            }
940    
941            /**
942            * 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.
943            *
944            * @param pk the primary key of the s c license
945            * @param scProductEntry the s c product entry
946            * @throws SystemException if a system exception occurred
947            */
948            public static void removeSCProductEntry(long pk,
949                    com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry)
950                    throws com.liferay.portal.kernel.exception.SystemException {
951                    getPersistence().removeSCProductEntry(pk, scProductEntry);
952            }
953    
954            /**
955            * 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.
956            *
957            * @param pk the primary key of the s c license
958            * @param scProductEntryPKs the primary keys of the s c product entries
959            * @throws SystemException if a system exception occurred
960            */
961            public static void removeSCProductEntries(long pk, long[] scProductEntryPKs)
962                    throws com.liferay.portal.kernel.exception.SystemException {
963                    getPersistence().removeSCProductEntries(pk, scProductEntryPKs);
964            }
965    
966            /**
967            * 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.
968            *
969            * @param pk the primary key of the s c license
970            * @param scProductEntries the s c product entries
971            * @throws SystemException if a system exception occurred
972            */
973            public static void removeSCProductEntries(long pk,
974                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries)
975                    throws com.liferay.portal.kernel.exception.SystemException {
976                    getPersistence().removeSCProductEntries(pk, scProductEntries);
977            }
978    
979            /**
980            * 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.
981            *
982            * @param pk the primary key of the s c license
983            * @param scProductEntryPKs the primary keys of the s c product entries to be associated with the s c license
984            * @throws SystemException if a system exception occurred
985            */
986            public static void setSCProductEntries(long pk, long[] scProductEntryPKs)
987                    throws com.liferay.portal.kernel.exception.SystemException {
988                    getPersistence().setSCProductEntries(pk, scProductEntryPKs);
989            }
990    
991            /**
992            * 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.
993            *
994            * @param pk the primary key of the s c license
995            * @param scProductEntries the s c product entries to be associated with the s c license
996            * @throws SystemException if a system exception occurred
997            */
998            public static void setSCProductEntries(long pk,
999                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries)
1000                    throws com.liferay.portal.kernel.exception.SystemException {
1001                    getPersistence().setSCProductEntries(pk, scProductEntries);
1002            }
1003    
1004            public static SCLicensePersistence getPersistence() {
1005                    if (_persistence == null) {
1006                            _persistence = (SCLicensePersistence)PortalBeanLocatorUtil.locate(SCLicensePersistence.class.getName());
1007    
1008                            ReferenceRegistry.registerReference(SCLicenseUtil.class,
1009                                    "_persistence");
1010                    }
1011    
1012                    return _persistence;
1013            }
1014    
1015            /**
1016             * @deprecated
1017             */
1018            public void setPersistence(SCLicensePersistence persistence) {
1019            }
1020    
1021            private static SCLicensePersistence _persistence;
1022    }