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