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