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.SCProductEntry;
022    
023    /**
024     * The persistence interface for the s c product entry 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.SCProductEntryPersistenceImpl
032     * @see SCProductEntryUtil
033     * @generated
034     */
035    @ProviderType
036    public interface SCProductEntryPersistence extends BasePersistence<SCProductEntry> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link SCProductEntryUtil} to access the s c product entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the s c product entries where groupId = &#63;.
045            *
046            * @param groupId the group ID
047            * @return the matching s c product entries
048            */
049            public java.util.List<SCProductEntry> findByGroupId(long groupId);
050    
051            /**
052            * Returns a range of all the s c product entries where groupId = &#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 SCProductEntryModelImpl}. 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 groupId the group ID
059            * @param start the lower bound of the range of s c product entries
060            * @param end the upper bound of the range of s c product entries (not inclusive)
061            * @return the range of matching s c product entries
062            */
063            public java.util.List<SCProductEntry> findByGroupId(long groupId,
064                    int start, int end);
065    
066            /**
067            * Returns an ordered range of all the s c product entries where groupId = &#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 SCProductEntryModelImpl}. 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 groupId the group ID
074            * @param start the lower bound of the range of s c product entries
075            * @param end the upper bound of the range of s c product entries (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 product entries
078            */
079            public java.util.List<SCProductEntry> findByGroupId(long groupId,
080                    int start, int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
082    
083            /**
084            * Returns the first s c product entry in the ordered set where groupId = &#63;.
085            *
086            * @param groupId the group ID
087            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
088            * @return the first matching s c product entry
089            * @throws NoSuchProductEntryException if a matching s c product entry could not be found
090            */
091            public SCProductEntry findByGroupId_First(long groupId,
092                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
093                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
094    
095            /**
096            * Returns the first s c product entry in the ordered set where groupId = &#63;.
097            *
098            * @param groupId the group ID
099            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
100            * @return the first matching s c product entry, or <code>null</code> if a matching s c product entry could not be found
101            */
102            public SCProductEntry fetchByGroupId_First(long groupId,
103                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
104    
105            /**
106            * Returns the last s c product entry in the ordered set where groupId = &#63;.
107            *
108            * @param groupId the group ID
109            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
110            * @return the last matching s c product entry
111            * @throws NoSuchProductEntryException if a matching s c product entry could not be found
112            */
113            public SCProductEntry findByGroupId_Last(long groupId,
114                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
115                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
116    
117            /**
118            * Returns the last s c product entry in the ordered set where groupId = &#63;.
119            *
120            * @param groupId the group ID
121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
122            * @return the last matching s c product entry, or <code>null</code> if a matching s c product entry could not be found
123            */
124            public SCProductEntry fetchByGroupId_Last(long groupId,
125                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
126    
127            /**
128            * Returns the s c product entries before and after the current s c product entry in the ordered set where groupId = &#63;.
129            *
130            * @param productEntryId the primary key of the current s c product entry
131            * @param groupId the group ID
132            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
133            * @return the previous, current, and next s c product entry
134            * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found
135            */
136            public SCProductEntry[] findByGroupId_PrevAndNext(long productEntryId,
137                    long groupId,
138                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
139                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
140    
141            /**
142            * Returns all the s c product entries that the user has permission to view where groupId = &#63;.
143            *
144            * @param groupId the group ID
145            * @return the matching s c product entries that the user has permission to view
146            */
147            public java.util.List<SCProductEntry> filterFindByGroupId(long groupId);
148    
149            /**
150            * Returns a range of all the s c product entries that the user has permission to view where groupId = &#63;.
151            *
152            * <p>
153            * 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 SCProductEntryModelImpl}. 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.
154            * </p>
155            *
156            * @param groupId the group ID
157            * @param start the lower bound of the range of s c product entries
158            * @param end the upper bound of the range of s c product entries (not inclusive)
159            * @return the range of matching s c product entries that the user has permission to view
160            */
161            public java.util.List<SCProductEntry> filterFindByGroupId(long groupId,
162                    int start, int end);
163    
164            /**
165            * Returns an ordered range of all the s c product entries that the user has permissions to view where groupId = &#63;.
166            *
167            * <p>
168            * 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 SCProductEntryModelImpl}. 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.
169            * </p>
170            *
171            * @param groupId the group ID
172            * @param start the lower bound of the range of s c product entries
173            * @param end the upper bound of the range of s c product entries (not inclusive)
174            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
175            * @return the ordered range of matching s c product entries that the user has permission to view
176            */
177            public java.util.List<SCProductEntry> filterFindByGroupId(long groupId,
178                    int start, int end,
179                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
180    
181            /**
182            * Returns the s c product entries before and after the current s c product entry in the ordered set of s c product entries that the user has permission to view where groupId = &#63;.
183            *
184            * @param productEntryId the primary key of the current s c product entry
185            * @param groupId the group ID
186            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
187            * @return the previous, current, and next s c product entry
188            * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found
189            */
190            public SCProductEntry[] filterFindByGroupId_PrevAndNext(
191                    long productEntryId, long groupId,
192                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
193                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
194    
195            /**
196            * Removes all the s c product entries where groupId = &#63; from the database.
197            *
198            * @param groupId the group ID
199            */
200            public void removeByGroupId(long groupId);
201    
202            /**
203            * Returns the number of s c product entries where groupId = &#63;.
204            *
205            * @param groupId the group ID
206            * @return the number of matching s c product entries
207            */
208            public int countByGroupId(long groupId);
209    
210            /**
211            * Returns the number of s c product entries that the user has permission to view where groupId = &#63;.
212            *
213            * @param groupId the group ID
214            * @return the number of matching s c product entries that the user has permission to view
215            */
216            public int filterCountByGroupId(long groupId);
217    
218            /**
219            * Returns all the s c product entries where companyId = &#63;.
220            *
221            * @param companyId the company ID
222            * @return the matching s c product entries
223            */
224            public java.util.List<SCProductEntry> findByCompanyId(long companyId);
225    
226            /**
227            * Returns a range of all the s c product entries where companyId = &#63;.
228            *
229            * <p>
230            * 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 SCProductEntryModelImpl}. 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.
231            * </p>
232            *
233            * @param companyId the company ID
234            * @param start the lower bound of the range of s c product entries
235            * @param end the upper bound of the range of s c product entries (not inclusive)
236            * @return the range of matching s c product entries
237            */
238            public java.util.List<SCProductEntry> findByCompanyId(long companyId,
239                    int start, int end);
240    
241            /**
242            * Returns an ordered range of all the s c product entries where companyId = &#63;.
243            *
244            * <p>
245            * 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 SCProductEntryModelImpl}. 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.
246            * </p>
247            *
248            * @param companyId the company ID
249            * @param start the lower bound of the range of s c product entries
250            * @param end the upper bound of the range of s c product entries (not inclusive)
251            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
252            * @return the ordered range of matching s c product entries
253            */
254            public java.util.List<SCProductEntry> findByCompanyId(long companyId,
255                    int start, int end,
256                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
257    
258            /**
259            * Returns the first s c product entry in the ordered set where companyId = &#63;.
260            *
261            * @param companyId the company ID
262            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
263            * @return the first matching s c product entry
264            * @throws NoSuchProductEntryException if a matching s c product entry could not be found
265            */
266            public SCProductEntry findByCompanyId_First(long companyId,
267                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
268                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
269    
270            /**
271            * Returns the first s c product entry in the ordered set where companyId = &#63;.
272            *
273            * @param companyId the company ID
274            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
275            * @return the first matching s c product entry, or <code>null</code> if a matching s c product entry could not be found
276            */
277            public SCProductEntry fetchByCompanyId_First(long companyId,
278                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
279    
280            /**
281            * Returns the last s c product entry in the ordered set where companyId = &#63;.
282            *
283            * @param companyId the company ID
284            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
285            * @return the last matching s c product entry
286            * @throws NoSuchProductEntryException if a matching s c product entry could not be found
287            */
288            public SCProductEntry findByCompanyId_Last(long companyId,
289                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
290                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
291    
292            /**
293            * Returns the last s c product entry in the ordered set where companyId = &#63;.
294            *
295            * @param companyId the company ID
296            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
297            * @return the last matching s c product entry, or <code>null</code> if a matching s c product entry could not be found
298            */
299            public SCProductEntry fetchByCompanyId_Last(long companyId,
300                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
301    
302            /**
303            * Returns the s c product entries before and after the current s c product entry in the ordered set where companyId = &#63;.
304            *
305            * @param productEntryId the primary key of the current s c product entry
306            * @param companyId the company ID
307            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
308            * @return the previous, current, and next s c product entry
309            * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found
310            */
311            public SCProductEntry[] findByCompanyId_PrevAndNext(long productEntryId,
312                    long companyId,
313                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
314                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
315    
316            /**
317            * Removes all the s c product entries where companyId = &#63; from the database.
318            *
319            * @param companyId the company ID
320            */
321            public void removeByCompanyId(long companyId);
322    
323            /**
324            * Returns the number of s c product entries where companyId = &#63;.
325            *
326            * @param companyId the company ID
327            * @return the number of matching s c product entries
328            */
329            public int countByCompanyId(long companyId);
330    
331            /**
332            * Returns all the s c product entries where groupId = &#63; and userId = &#63;.
333            *
334            * @param groupId the group ID
335            * @param userId the user ID
336            * @return the matching s c product entries
337            */
338            public java.util.List<SCProductEntry> findByG_U(long groupId, long userId);
339    
340            /**
341            * Returns a range of all the s c product entries where groupId = &#63; and userId = &#63;.
342            *
343            * <p>
344            * 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 SCProductEntryModelImpl}. 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.
345            * </p>
346            *
347            * @param groupId the group ID
348            * @param userId the user ID
349            * @param start the lower bound of the range of s c product entries
350            * @param end the upper bound of the range of s c product entries (not inclusive)
351            * @return the range of matching s c product entries
352            */
353            public java.util.List<SCProductEntry> findByG_U(long groupId, long userId,
354                    int start, int end);
355    
356            /**
357            * Returns an ordered range of all the s c product entries where groupId = &#63; and userId = &#63;.
358            *
359            * <p>
360            * 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 SCProductEntryModelImpl}. 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.
361            * </p>
362            *
363            * @param groupId the group ID
364            * @param userId the user ID
365            * @param start the lower bound of the range of s c product entries
366            * @param end the upper bound of the range of s c product entries (not inclusive)
367            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
368            * @return the ordered range of matching s c product entries
369            */
370            public java.util.List<SCProductEntry> findByG_U(long groupId, long userId,
371                    int start, int end,
372                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
373    
374            /**
375            * Returns the first s c product entry in the ordered set where groupId = &#63; and userId = &#63;.
376            *
377            * @param groupId the group ID
378            * @param userId the user ID
379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
380            * @return the first matching s c product entry
381            * @throws NoSuchProductEntryException if a matching s c product entry could not be found
382            */
383            public SCProductEntry findByG_U_First(long groupId, long userId,
384                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
385                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
386    
387            /**
388            * Returns the first s c product entry in the ordered set where groupId = &#63; and userId = &#63;.
389            *
390            * @param groupId the group ID
391            * @param userId the user ID
392            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
393            * @return the first matching s c product entry, or <code>null</code> if a matching s c product entry could not be found
394            */
395            public SCProductEntry fetchByG_U_First(long groupId, long userId,
396                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
397    
398            /**
399            * Returns the last s c product entry in the ordered set where groupId = &#63; and userId = &#63;.
400            *
401            * @param groupId the group ID
402            * @param userId the user ID
403            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
404            * @return the last matching s c product entry
405            * @throws NoSuchProductEntryException if a matching s c product entry could not be found
406            */
407            public SCProductEntry findByG_U_Last(long groupId, long userId,
408                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
409                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
410    
411            /**
412            * Returns the last s c product entry in the ordered set where groupId = &#63; and userId = &#63;.
413            *
414            * @param groupId the group ID
415            * @param userId the user ID
416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
417            * @return the last matching s c product entry, or <code>null</code> if a matching s c product entry could not be found
418            */
419            public SCProductEntry fetchByG_U_Last(long groupId, long userId,
420                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
421    
422            /**
423            * Returns the s c product entries before and after the current s c product entry in the ordered set where groupId = &#63; and userId = &#63;.
424            *
425            * @param productEntryId the primary key of the current s c product entry
426            * @param groupId the group ID
427            * @param userId the user ID
428            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
429            * @return the previous, current, and next s c product entry
430            * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found
431            */
432            public SCProductEntry[] findByG_U_PrevAndNext(long productEntryId,
433                    long groupId, long userId,
434                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
435                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
436    
437            /**
438            * Returns all the s c product entries that the user has permission to view where groupId = &#63; and userId = &#63;.
439            *
440            * @param groupId the group ID
441            * @param userId the user ID
442            * @return the matching s c product entries that the user has permission to view
443            */
444            public java.util.List<SCProductEntry> filterFindByG_U(long groupId,
445                    long userId);
446    
447            /**
448            * Returns a range of all the s c product entries that the user has permission to view where groupId = &#63; and userId = &#63;.
449            *
450            * <p>
451            * 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 SCProductEntryModelImpl}. 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.
452            * </p>
453            *
454            * @param groupId the group ID
455            * @param userId the user ID
456            * @param start the lower bound of the range of s c product entries
457            * @param end the upper bound of the range of s c product entries (not inclusive)
458            * @return the range of matching s c product entries that the user has permission to view
459            */
460            public java.util.List<SCProductEntry> filterFindByG_U(long groupId,
461                    long userId, int start, int end);
462    
463            /**
464            * Returns an ordered range of all the s c product entries that the user has permissions to view where groupId = &#63; and userId = &#63;.
465            *
466            * <p>
467            * 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 SCProductEntryModelImpl}. 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.
468            * </p>
469            *
470            * @param groupId the group ID
471            * @param userId the user ID
472            * @param start the lower bound of the range of s c product entries
473            * @param end the upper bound of the range of s c product entries (not inclusive)
474            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
475            * @return the ordered range of matching s c product entries that the user has permission to view
476            */
477            public java.util.List<SCProductEntry> filterFindByG_U(long groupId,
478                    long userId, int start, int end,
479                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
480    
481            /**
482            * Returns the s c product entries before and after the current s c product entry in the ordered set of s c product entries that the user has permission to view where groupId = &#63; and userId = &#63;.
483            *
484            * @param productEntryId the primary key of the current s c product entry
485            * @param groupId the group ID
486            * @param userId the user ID
487            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
488            * @return the previous, current, and next s c product entry
489            * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found
490            */
491            public SCProductEntry[] filterFindByG_U_PrevAndNext(long productEntryId,
492                    long groupId, long userId,
493                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator)
494                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
495    
496            /**
497            * Removes all the s c product entries where groupId = &#63; and userId = &#63; from the database.
498            *
499            * @param groupId the group ID
500            * @param userId the user ID
501            */
502            public void removeByG_U(long groupId, long userId);
503    
504            /**
505            * Returns the number of s c product entries where groupId = &#63; and userId = &#63;.
506            *
507            * @param groupId the group ID
508            * @param userId the user ID
509            * @return the number of matching s c product entries
510            */
511            public int countByG_U(long groupId, long userId);
512    
513            /**
514            * Returns the number of s c product entries that the user has permission to view where groupId = &#63; and userId = &#63;.
515            *
516            * @param groupId the group ID
517            * @param userId the user ID
518            * @return the number of matching s c product entries that the user has permission to view
519            */
520            public int filterCountByG_U(long groupId, long userId);
521    
522            /**
523            * Returns the s c product entry where repoGroupId = &#63; and repoArtifactId = &#63; or throws a {@link NoSuchProductEntryException} if it could not be found.
524            *
525            * @param repoGroupId the repo group ID
526            * @param repoArtifactId the repo artifact ID
527            * @return the matching s c product entry
528            * @throws NoSuchProductEntryException if a matching s c product entry could not be found
529            */
530            public SCProductEntry findByRG_RA(java.lang.String repoGroupId,
531                    java.lang.String repoArtifactId)
532                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
533    
534            /**
535            * Returns the s c product entry where repoGroupId = &#63; and repoArtifactId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
536            *
537            * @param repoGroupId the repo group ID
538            * @param repoArtifactId the repo artifact ID
539            * @return the matching s c product entry, or <code>null</code> if a matching s c product entry could not be found
540            */
541            public SCProductEntry fetchByRG_RA(java.lang.String repoGroupId,
542                    java.lang.String repoArtifactId);
543    
544            /**
545            * Returns the s c product entry where repoGroupId = &#63; and repoArtifactId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
546            *
547            * @param repoGroupId the repo group ID
548            * @param repoArtifactId the repo artifact ID
549            * @param retrieveFromCache whether to use the finder cache
550            * @return the matching s c product entry, or <code>null</code> if a matching s c product entry could not be found
551            */
552            public SCProductEntry fetchByRG_RA(java.lang.String repoGroupId,
553                    java.lang.String repoArtifactId, boolean retrieveFromCache);
554    
555            /**
556            * Removes the s c product entry where repoGroupId = &#63; and repoArtifactId = &#63; from the database.
557            *
558            * @param repoGroupId the repo group ID
559            * @param repoArtifactId the repo artifact ID
560            * @return the s c product entry that was removed
561            */
562            public SCProductEntry removeByRG_RA(java.lang.String repoGroupId,
563                    java.lang.String repoArtifactId)
564                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
565    
566            /**
567            * Returns the number of s c product entries where repoGroupId = &#63; and repoArtifactId = &#63;.
568            *
569            * @param repoGroupId the repo group ID
570            * @param repoArtifactId the repo artifact ID
571            * @return the number of matching s c product entries
572            */
573            public int countByRG_RA(java.lang.String repoGroupId,
574                    java.lang.String repoArtifactId);
575    
576            /**
577            * Caches the s c product entry in the entity cache if it is enabled.
578            *
579            * @param scProductEntry the s c product entry
580            */
581            public void cacheResult(SCProductEntry scProductEntry);
582    
583            /**
584            * Caches the s c product entries in the entity cache if it is enabled.
585            *
586            * @param scProductEntries the s c product entries
587            */
588            public void cacheResult(java.util.List<SCProductEntry> scProductEntries);
589    
590            /**
591            * Creates a new s c product entry with the primary key. Does not add the s c product entry to the database.
592            *
593            * @param productEntryId the primary key for the new s c product entry
594            * @return the new s c product entry
595            */
596            public SCProductEntry create(long productEntryId);
597    
598            /**
599            * Removes the s c product entry with the primary key from the database. Also notifies the appropriate model listeners.
600            *
601            * @param productEntryId the primary key of the s c product entry
602            * @return the s c product entry that was removed
603            * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found
604            */
605            public SCProductEntry remove(long productEntryId)
606                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
607    
608            public SCProductEntry updateImpl(SCProductEntry scProductEntry);
609    
610            /**
611            * Returns the s c product entry with the primary key or throws a {@link NoSuchProductEntryException} if it could not be found.
612            *
613            * @param productEntryId the primary key of the s c product entry
614            * @return the s c product entry
615            * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found
616            */
617            public SCProductEntry findByPrimaryKey(long productEntryId)
618                    throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException;
619    
620            /**
621            * Returns the s c product entry with the primary key or returns <code>null</code> if it could not be found.
622            *
623            * @param productEntryId the primary key of the s c product entry
624            * @return the s c product entry, or <code>null</code> if a s c product entry with the primary key could not be found
625            */
626            public SCProductEntry fetchByPrimaryKey(long productEntryId);
627    
628            @Override
629            public java.util.Map<java.io.Serializable, SCProductEntry> fetchByPrimaryKeys(
630                    java.util.Set<java.io.Serializable> primaryKeys);
631    
632            /**
633            * Returns all the s c product entries.
634            *
635            * @return the s c product entries
636            */
637            public java.util.List<SCProductEntry> findAll();
638    
639            /**
640            * Returns a range of all the s c product entries.
641            *
642            * <p>
643            * 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 SCProductEntryModelImpl}. 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.
644            * </p>
645            *
646            * @param start the lower bound of the range of s c product entries
647            * @param end the upper bound of the range of s c product entries (not inclusive)
648            * @return the range of s c product entries
649            */
650            public java.util.List<SCProductEntry> findAll(int start, int end);
651    
652            /**
653            * Returns an ordered range of all the s c product entries.
654            *
655            * <p>
656            * 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 SCProductEntryModelImpl}. 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.
657            * </p>
658            *
659            * @param start the lower bound of the range of s c product entries
660            * @param end the upper bound of the range of s c product entries (not inclusive)
661            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
662            * @return the ordered range of s c product entries
663            */
664            public java.util.List<SCProductEntry> findAll(int start, int end,
665                    com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator);
666    
667            /**
668            * Removes all the s c product entries from the database.
669            */
670            public void removeAll();
671    
672            /**
673            * Returns the number of s c product entries.
674            *
675            * @return the number of s c product entries
676            */
677            public int countAll();
678    
679            /**
680            * Returns the primaryKeys of s c licenses associated with the s c product entry.
681            *
682            * @param pk the primary key of the s c product entry
683            * @return long[] of the primaryKeys of s c licenses associated with the s c product entry
684            */
685            public long[] getSCLicensePrimaryKeys(long pk);
686    
687            /**
688            * Returns all the s c licenses associated with the s c product entry.
689            *
690            * @param pk the primary key of the s c product entry
691            * @return the s c licenses associated with the s c product entry
692            */
693            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses(
694                    long pk);
695    
696            /**
697            * Returns a range of all the s c licenses associated with the s c product entry.
698            *
699            * <p>
700            * 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 SCProductEntryModelImpl}. 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.
701            * </p>
702            *
703            * @param pk the primary key of the s c product entry
704            * @param start the lower bound of the range of s c product entries
705            * @param end the upper bound of the range of s c product entries (not inclusive)
706            * @return the range of s c licenses associated with the s c product entry
707            */
708            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses(
709                    long pk, int start, int end);
710    
711            /**
712            * Returns an ordered range of all the s c licenses associated with the s c product entry.
713            *
714            * <p>
715            * 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 SCProductEntryModelImpl}. 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.
716            * </p>
717            *
718            * @param pk the primary key of the s c product entry
719            * @param start the lower bound of the range of s c product entries
720            * @param end the upper bound of the range of s c product entries (not inclusive)
721            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
722            * @return the ordered range of s c licenses associated with the s c product entry
723            */
724            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses(
725                    long pk, int start, int end,
726                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator);
727    
728            /**
729            * Returns the number of s c licenses associated with the s c product entry.
730            *
731            * @param pk the primary key of the s c product entry
732            * @return the number of s c licenses associated with the s c product entry
733            */
734            public int getSCLicensesSize(long pk);
735    
736            /**
737            * Returns <code>true</code> if the s c license is associated with the s c product entry.
738            *
739            * @param pk the primary key of the s c product entry
740            * @param scLicensePK the primary key of the s c license
741            * @return <code>true</code> if the s c license is associated with the s c product entry; <code>false</code> otherwise
742            */
743            public boolean containsSCLicense(long pk, long scLicensePK);
744    
745            /**
746            * Returns <code>true</code> if the s c product entry has any s c licenses associated with it.
747            *
748            * @param pk the primary key of the s c product entry to check for associations with s c licenses
749            * @return <code>true</code> if the s c product entry has any s c licenses associated with it; <code>false</code> otherwise
750            */
751            public boolean containsSCLicenses(long pk);
752    
753            /**
754            * Adds an association between the s c product entry and the s c license. Also notifies the appropriate model listeners and clears the mapping table finder cache.
755            *
756            * @param pk the primary key of the s c product entry
757            * @param scLicensePK the primary key of the s c license
758            */
759            public void addSCLicense(long pk, long scLicensePK);
760    
761            /**
762            * Adds an association between the s c product entry and the s c license. Also notifies the appropriate model listeners and clears the mapping table finder cache.
763            *
764            * @param pk the primary key of the s c product entry
765            * @param scLicense the s c license
766            */
767            public void addSCLicense(long pk,
768                    com.liferay.portlet.softwarecatalog.model.SCLicense scLicense);
769    
770            /**
771            * Adds an association between the s c product entry and the s c licenses. Also notifies the appropriate model listeners and clears the mapping table finder cache.
772            *
773            * @param pk the primary key of the s c product entry
774            * @param scLicensePKs the primary keys of the s c licenses
775            */
776            public void addSCLicenses(long pk, long[] scLicensePKs);
777    
778            /**
779            * Adds an association between the s c product entry and the s c licenses. Also notifies the appropriate model listeners and clears the mapping table finder cache.
780            *
781            * @param pk the primary key of the s c product entry
782            * @param scLicenses the s c licenses
783            */
784            public void addSCLicenses(long pk,
785                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses);
786    
787            /**
788            * Clears all associations between the s c product entry and its s c licenses. Also notifies the appropriate model listeners and clears the mapping table finder cache.
789            *
790            * @param pk the primary key of the s c product entry to clear the associated s c licenses from
791            */
792            public void clearSCLicenses(long pk);
793    
794            /**
795            * Removes the association between the s c product entry and the s c license. Also notifies the appropriate model listeners and clears the mapping table finder cache.
796            *
797            * @param pk the primary key of the s c product entry
798            * @param scLicensePK the primary key of the s c license
799            */
800            public void removeSCLicense(long pk, long scLicensePK);
801    
802            /**
803            * Removes the association between the s c product entry and the s c license. Also notifies the appropriate model listeners and clears the mapping table finder cache.
804            *
805            * @param pk the primary key of the s c product entry
806            * @param scLicense the s c license
807            */
808            public void removeSCLicense(long pk,
809                    com.liferay.portlet.softwarecatalog.model.SCLicense scLicense);
810    
811            /**
812            * Removes the association between the s c product entry and the s c licenses. Also notifies the appropriate model listeners and clears the mapping table finder cache.
813            *
814            * @param pk the primary key of the s c product entry
815            * @param scLicensePKs the primary keys of the s c licenses
816            */
817            public void removeSCLicenses(long pk, long[] scLicensePKs);
818    
819            /**
820            * Removes the association between the s c product entry and the s c licenses. Also notifies the appropriate model listeners and clears the mapping table finder cache.
821            *
822            * @param pk the primary key of the s c product entry
823            * @param scLicenses the s c licenses
824            */
825            public void removeSCLicenses(long pk,
826                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses);
827    
828            /**
829            * Sets the s c licenses associated with the s c product entry, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
830            *
831            * @param pk the primary key of the s c product entry
832            * @param scLicensePKs the primary keys of the s c licenses to be associated with the s c product entry
833            */
834            public void setSCLicenses(long pk, long[] scLicensePKs);
835    
836            /**
837            * Sets the s c licenses associated with the s c product entry, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
838            *
839            * @param pk the primary key of the s c product entry
840            * @param scLicenses the s c licenses to be associated with the s c product entry
841            */
842            public void setSCLicenses(long pk,
843                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses);
844    }