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