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