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