001    /**
002     * Copyright (c) 2000-present 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.service.persistence.BasePersistence;
020    
021    import com.liferay.portlet.softwarecatalog.model.SCLicense;
022    
023    /**
024     * The persistence interface for the s c license service.
025     *
026     * <p>
027     * Caching information and settings can be found in <code>portal.properties</code>
028     * </p>
029     *
030     * @author Brian Wing Shun Chan
031     * @see SCLicensePersistenceImpl
032     * @see SCLicenseUtil
033     * @generated
034     */
035    @ProviderType
036    public interface SCLicensePersistence extends BasePersistence<SCLicense> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link SCLicenseUtil} to access the s c license persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the s c licenses where active = &#63;.
045            *
046            * @param active the active
047            * @return the matching s c licenses
048            */
049            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive(
050                    boolean active);
051    
052            /**
053            * Returns a range of all the s c licenses where active = &#63;.
054            *
055            * <p>
056            * 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.
057            * </p>
058            *
059            * @param active the active
060            * @param start the lower bound of the range of s c licenses
061            * @param end the upper bound of the range of s c licenses (not inclusive)
062            * @return the range of matching s c licenses
063            */
064            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive(
065                    boolean active, int start, int end);
066    
067            /**
068            * Returns an ordered range of all the s c licenses where active = &#63;.
069            *
070            * <p>
071            * 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.
072            * </p>
073            *
074            * @param active the active
075            * @param start the lower bound of the range of s c licenses
076            * @param end the upper bound of the range of s c licenses (not inclusive)
077            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
078            * @return the ordered range of matching s c licenses
079            */
080            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive(
081                    boolean active, int start, int end,
082                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator);
083    
084            /**
085            * Returns the first s c license in the ordered set where active = &#63;.
086            *
087            * @param active the active
088            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
089            * @return the first matching s c license
090            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
091            */
092            public com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_First(
093                    boolean active,
094                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator)
095                    throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException;
096    
097            /**
098            * Returns the first s c license in the ordered set where active = &#63;.
099            *
100            * @param active the active
101            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
102            * @return the first matching s c license, or <code>null</code> if a matching s c license could not be found
103            */
104            public com.liferay.portlet.softwarecatalog.model.SCLicense fetchByActive_First(
105                    boolean active,
106                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator);
107    
108            /**
109            * Returns the last s c license in the ordered set where active = &#63;.
110            *
111            * @param active the active
112            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
113            * @return the last matching s c license
114            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
115            */
116            public com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_Last(
117                    boolean active,
118                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator)
119                    throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException;
120    
121            /**
122            * Returns the last s c license in the ordered set where active = &#63;.
123            *
124            * @param active the active
125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
126            * @return the last matching s c license, or <code>null</code> if a matching s c license could not be found
127            */
128            public com.liferay.portlet.softwarecatalog.model.SCLicense fetchByActive_Last(
129                    boolean active,
130                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator);
131    
132            /**
133            * Returns the s c licenses before and after the current s c license in the ordered set where active = &#63;.
134            *
135            * @param licenseId the primary key of the current s c license
136            * @param active the active
137            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
138            * @return the previous, current, and next s c license
139            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
140            */
141            public com.liferay.portlet.softwarecatalog.model.SCLicense[] findByActive_PrevAndNext(
142                    long licenseId, boolean active,
143                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator)
144                    throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException;
145    
146            /**
147            * Returns all the s c licenses that the user has permission to view where active = &#63;.
148            *
149            * @param active the active
150            * @return the matching s c licenses that the user has permission to view
151            */
152            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive(
153                    boolean active);
154    
155            /**
156            * Returns a range of all the s c licenses that the user has permission to view where active = &#63;.
157            *
158            * <p>
159            * 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.
160            * </p>
161            *
162            * @param active the active
163            * @param start the lower bound of the range of s c licenses
164            * @param end the upper bound of the range of s c licenses (not inclusive)
165            * @return the range of matching s c licenses that the user has permission to view
166            */
167            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive(
168                    boolean active, int start, int end);
169    
170            /**
171            * Returns an ordered range of all the s c licenses that the user has permissions to view where active = &#63;.
172            *
173            * <p>
174            * 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.
175            * </p>
176            *
177            * @param active the active
178            * @param start the lower bound of the range of s c licenses
179            * @param end the upper bound of the range of s c licenses (not inclusive)
180            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
181            * @return the ordered range of matching s c licenses that the user has permission to view
182            */
183            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive(
184                    boolean active, int start, int end,
185                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator);
186    
187            /**
188            * 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;.
189            *
190            * @param licenseId the primary key of the current s c license
191            * @param active the active
192            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
193            * @return the previous, current, and next s c license
194            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
195            */
196            public com.liferay.portlet.softwarecatalog.model.SCLicense[] filterFindByActive_PrevAndNext(
197                    long licenseId, boolean active,
198                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator)
199                    throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException;
200    
201            /**
202            * Removes all the s c licenses where active = &#63; from the database.
203            *
204            * @param active the active
205            */
206            public void removeByActive(boolean active);
207    
208            /**
209            * Returns the number of s c licenses where active = &#63;.
210            *
211            * @param active the active
212            * @return the number of matching s c licenses
213            */
214            public int countByActive(boolean active);
215    
216            /**
217            * Returns the number of s c licenses that the user has permission to view where active = &#63;.
218            *
219            * @param active the active
220            * @return the number of matching s c licenses that the user has permission to view
221            */
222            public int filterCountByActive(boolean active);
223    
224            /**
225            * Returns all the s c licenses where active = &#63; and recommended = &#63;.
226            *
227            * @param active the active
228            * @param recommended the recommended
229            * @return the matching s c licenses
230            */
231            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
232                    boolean active, boolean recommended);
233    
234            /**
235            * Returns a range of all the s c licenses where active = &#63; and recommended = &#63;.
236            *
237            * <p>
238            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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.
239            * </p>
240            *
241            * @param active the active
242            * @param recommended the recommended
243            * @param start the lower bound of the range of s c licenses
244            * @param end the upper bound of the range of s c licenses (not inclusive)
245            * @return the range of matching s c licenses
246            */
247            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
248                    boolean active, boolean recommended, int start, int end);
249    
250            /**
251            * Returns an ordered range of all the s c licenses where active = &#63; and recommended = &#63;.
252            *
253            * <p>
254            * 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.
255            * </p>
256            *
257            * @param active the active
258            * @param recommended the recommended
259            * @param start the lower bound of the range of s c licenses
260            * @param end the upper bound of the range of s c licenses (not inclusive)
261            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
262            * @return the ordered range of matching s c licenses
263            */
264            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R(
265                    boolean active, boolean recommended, int start, int end,
266                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator);
267    
268            /**
269            * Returns the first s c license in the ordered set where active = &#63; and recommended = &#63;.
270            *
271            * @param active the active
272            * @param recommended the recommended
273            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
274            * @return the first matching s c license
275            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
276            */
277            public com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_First(
278                    boolean active, boolean recommended,
279                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator)
280                    throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException;
281    
282            /**
283            * Returns the first s c license in the ordered set where active = &#63; and recommended = &#63;.
284            *
285            * @param active the active
286            * @param recommended the recommended
287            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
288            * @return the first matching s c license, or <code>null</code> if a matching s c license could not be found
289            */
290            public com.liferay.portlet.softwarecatalog.model.SCLicense fetchByA_R_First(
291                    boolean active, boolean recommended,
292                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator);
293    
294            /**
295            * Returns the last s c license in the ordered set where active = &#63; and recommended = &#63;.
296            *
297            * @param active the active
298            * @param recommended the recommended
299            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
300            * @return the last matching s c license
301            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found
302            */
303            public com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_Last(
304                    boolean active, boolean recommended,
305                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator)
306                    throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException;
307    
308            /**
309            * Returns the last s c license in the ordered set where active = &#63; and recommended = &#63;.
310            *
311            * @param active the active
312            * @param recommended the recommended
313            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
314            * @return the last matching s c license, or <code>null</code> if a matching s c license could not be found
315            */
316            public com.liferay.portlet.softwarecatalog.model.SCLicense fetchByA_R_Last(
317                    boolean active, boolean recommended,
318                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator);
319    
320            /**
321            * Returns the s c licenses before and after the current s c license in the ordered set where active = &#63; and recommended = &#63;.
322            *
323            * @param licenseId the primary key of the current s c license
324            * @param active the active
325            * @param recommended the recommended
326            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
327            * @return the previous, current, and next s c license
328            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
329            */
330            public com.liferay.portlet.softwarecatalog.model.SCLicense[] findByA_R_PrevAndNext(
331                    long licenseId, boolean active, boolean recommended,
332                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator)
333                    throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException;
334    
335            /**
336            * Returns all the s c licenses that the user has permission to view where active = &#63; and recommended = &#63;.
337            *
338            * @param active the active
339            * @param recommended the recommended
340            * @return the matching s c licenses that the user has permission to view
341            */
342            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R(
343                    boolean active, boolean recommended);
344    
345            /**
346            * Returns a range of all the s c licenses that the user has permission to view where active = &#63; and recommended = &#63;.
347            *
348            * <p>
349            * 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.
350            * </p>
351            *
352            * @param active the active
353            * @param recommended the recommended
354            * @param start the lower bound of the range of s c licenses
355            * @param end the upper bound of the range of s c licenses (not inclusive)
356            * @return the range of matching s c licenses that the user has permission to view
357            */
358            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R(
359                    boolean active, boolean recommended, int start, int end);
360    
361            /**
362            * Returns an ordered range of all the s c licenses that the user has permissions to view where active = &#63; and recommended = &#63;.
363            *
364            * <p>
365            * 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.
366            * </p>
367            *
368            * @param active the active
369            * @param recommended the recommended
370            * @param start the lower bound of the range of s c licenses
371            * @param end the upper bound of the range of s c licenses (not inclusive)
372            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
373            * @return the ordered range of matching s c licenses that the user has permission to view
374            */
375            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R(
376                    boolean active, boolean recommended, int start, int end,
377                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator);
378    
379            /**
380            * 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;.
381            *
382            * @param licenseId the primary key of the current s c license
383            * @param active the active
384            * @param recommended the recommended
385            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
386            * @return the previous, current, and next s c license
387            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
388            */
389            public com.liferay.portlet.softwarecatalog.model.SCLicense[] filterFindByA_R_PrevAndNext(
390                    long licenseId, boolean active, boolean recommended,
391                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator)
392                    throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException;
393    
394            /**
395            * Removes all the s c licenses where active = &#63; and recommended = &#63; from the database.
396            *
397            * @param active the active
398            * @param recommended the recommended
399            */
400            public void removeByA_R(boolean active, boolean recommended);
401    
402            /**
403            * Returns the number of s c licenses where active = &#63; and recommended = &#63;.
404            *
405            * @param active the active
406            * @param recommended the recommended
407            * @return the number of matching s c licenses
408            */
409            public int countByA_R(boolean active, boolean recommended);
410    
411            /**
412            * Returns the number of s c licenses that the user has permission to view where active = &#63; and recommended = &#63;.
413            *
414            * @param active the active
415            * @param recommended the recommended
416            * @return the number of matching s c licenses that the user has permission to view
417            */
418            public int filterCountByA_R(boolean active, boolean recommended);
419    
420            /**
421            * Caches the s c license in the entity cache if it is enabled.
422            *
423            * @param scLicense the s c license
424            */
425            public void cacheResult(
426                    com.liferay.portlet.softwarecatalog.model.SCLicense scLicense);
427    
428            /**
429            * Caches the s c licenses in the entity cache if it is enabled.
430            *
431            * @param scLicenses the s c licenses
432            */
433            public void cacheResult(
434                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses);
435    
436            /**
437            * Creates a new s c license with the primary key. Does not add the s c license to the database.
438            *
439            * @param licenseId the primary key for the new s c license
440            * @return the new s c license
441            */
442            public com.liferay.portlet.softwarecatalog.model.SCLicense create(
443                    long licenseId);
444    
445            /**
446            * Removes the s c license with the primary key from the database. Also notifies the appropriate model listeners.
447            *
448            * @param licenseId the primary key of the s c license
449            * @return the s c license that was removed
450            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
451            */
452            public com.liferay.portlet.softwarecatalog.model.SCLicense remove(
453                    long licenseId)
454                    throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException;
455    
456            public com.liferay.portlet.softwarecatalog.model.SCLicense updateImpl(
457                    com.liferay.portlet.softwarecatalog.model.SCLicense scLicense);
458    
459            /**
460            * Returns the s c license with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchLicenseException} if it could not be found.
461            *
462            * @param licenseId the primary key of the s c license
463            * @return the s c license
464            * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found
465            */
466            public com.liferay.portlet.softwarecatalog.model.SCLicense findByPrimaryKey(
467                    long licenseId)
468                    throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException;
469    
470            /**
471            * Returns the s c license with the primary key or returns <code>null</code> if it could not be found.
472            *
473            * @param licenseId the primary key of the s c license
474            * @return the s c license, or <code>null</code> if a s c license with the primary key could not be found
475            */
476            public com.liferay.portlet.softwarecatalog.model.SCLicense fetchByPrimaryKey(
477                    long licenseId);
478    
479            @Override
480            public java.util.Map<java.io.Serializable, com.liferay.portlet.softwarecatalog.model.SCLicense> fetchByPrimaryKeys(
481                    java.util.Set<java.io.Serializable> primaryKeys);
482    
483            /**
484            * Returns all the s c licenses.
485            *
486            * @return the s c licenses
487            */
488            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll();
489    
490            /**
491            * Returns a range of all the s c licenses.
492            *
493            * <p>
494            * 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.
495            * </p>
496            *
497            * @param start the lower bound of the range of s c licenses
498            * @param end the upper bound of the range of s c licenses (not inclusive)
499            * @return the range of s c licenses
500            */
501            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll(
502                    int start, int end);
503    
504            /**
505            * Returns an ordered range of all the s c licenses.
506            *
507            * <p>
508            * 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.
509            * </p>
510            *
511            * @param start the lower bound of the range of s c licenses
512            * @param end the upper bound of the range of s c licenses (not inclusive)
513            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
514            * @return the ordered range of s c licenses
515            */
516            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll(
517                    int start, int end,
518                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator);
519    
520            /**
521            * Removes all the s c licenses from the database.
522            */
523            public void removeAll();
524    
525            /**
526            * Returns the number of s c licenses.
527            *
528            * @return the number of s c licenses
529            */
530            public int countAll();
531    
532            /**
533            * Returns the primaryKeys of s c product entries associated with the s c license.
534            *
535            * @param pk the primary key of the s c license
536            * @return long[] of the primaryKeys of s c product entries associated with the s c license
537            */
538            public long[] getSCProductEntryPrimaryKeys(long pk);
539    
540            /**
541            * Returns all the s c product entries associated with the s c license.
542            *
543            * @param pk the primary key of the s c license
544            * @return the s c product entries associated with the s c license
545            */
546            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
547                    long pk);
548    
549            /**
550            * Returns a range of all the s c product entries associated with the s c license.
551            *
552            * <p>
553            * 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.
554            * </p>
555            *
556            * @param pk the primary key of the s c license
557            * @param start the lower bound of the range of s c licenses
558            * @param end the upper bound of the range of s c licenses (not inclusive)
559            * @return the range of s c product entries associated with the s c license
560            */
561            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
562                    long pk, int start, int end);
563    
564            /**
565            * Returns an ordered range of all the s c product entries associated with the s c license.
566            *
567            * <p>
568            * 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.
569            * </p>
570            *
571            * @param pk the primary key of the s c license
572            * @param start the lower bound of the range of s c licenses
573            * @param end the upper bound of the range of s c licenses (not inclusive)
574            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
575            * @return the ordered range of s c product entries associated with the s c license
576            */
577            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries(
578                    long pk, int start, int end,
579                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCProductEntry> orderByComparator);
580    
581            /**
582            * Returns the number of s c product entries associated with the s c license.
583            *
584            * @param pk the primary key of the s c license
585            * @return the number of s c product entries associated with the s c license
586            */
587            public int getSCProductEntriesSize(long pk);
588    
589            /**
590            * Returns <code>true</code> if the s c product entry is associated with the s c license.
591            *
592            * @param pk the primary key of the s c license
593            * @param scProductEntryPK the primary key of the s c product entry
594            * @return <code>true</code> if the s c product entry is associated with the s c license; <code>false</code> otherwise
595            */
596            public boolean containsSCProductEntry(long pk, long scProductEntryPK);
597    
598            /**
599            * Returns <code>true</code> if the s c license has any s c product entries associated with it.
600            *
601            * @param pk the primary key of the s c license to check for associations with s c product entries
602            * @return <code>true</code> if the s c license has any s c product entries associated with it; <code>false</code> otherwise
603            */
604            public boolean containsSCProductEntries(long pk);
605    
606            /**
607            * 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.
608            *
609            * @param pk the primary key of the s c license
610            * @param scProductEntryPK the primary key of the s c product entry
611            */
612            public void addSCProductEntry(long pk, long scProductEntryPK);
613    
614            /**
615            * 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.
616            *
617            * @param pk the primary key of the s c license
618            * @param scProductEntry the s c product entry
619            */
620            public void addSCProductEntry(long pk,
621                    com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry);
622    
623            /**
624            * 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.
625            *
626            * @param pk the primary key of the s c license
627            * @param scProductEntryPKs the primary keys of the s c product entries
628            */
629            public void addSCProductEntries(long pk, long[] scProductEntryPKs);
630    
631            /**
632            * 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.
633            *
634            * @param pk the primary key of the s c license
635            * @param scProductEntries the s c product entries
636            */
637            public void addSCProductEntries(long pk,
638                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries);
639    
640            /**
641            * 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.
642            *
643            * @param pk the primary key of the s c license to clear the associated s c product entries from
644            */
645            public void clearSCProductEntries(long pk);
646    
647            /**
648            * 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.
649            *
650            * @param pk the primary key of the s c license
651            * @param scProductEntryPK the primary key of the s c product entry
652            */
653            public void removeSCProductEntry(long pk, long scProductEntryPK);
654    
655            /**
656            * 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.
657            *
658            * @param pk the primary key of the s c license
659            * @param scProductEntry the s c product entry
660            */
661            public void removeSCProductEntry(long pk,
662                    com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry);
663    
664            /**
665            * 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.
666            *
667            * @param pk the primary key of the s c license
668            * @param scProductEntryPKs the primary keys of the s c product entries
669            */
670            public void removeSCProductEntries(long pk, long[] scProductEntryPKs);
671    
672            /**
673            * 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.
674            *
675            * @param pk the primary key of the s c license
676            * @param scProductEntries the s c product entries
677            */
678            public void removeSCProductEntries(long pk,
679                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries);
680    
681            /**
682            * 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.
683            *
684            * @param pk the primary key of the s c license
685            * @param scProductEntryPKs the primary keys of the s c product entries to be associated with the s c license
686            */
687            public void setSCProductEntries(long pk, long[] scProductEntryPKs);
688    
689            /**
690            * 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.
691            *
692            * @param pk the primary key of the s c license
693            * @param scProductEntries the s c product entries to be associated with the s c license
694            */
695            public void setSCProductEntries(long pk,
696                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries);
697    }