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