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