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