001    /**
002     * Copyright (c) 2000-2010 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 com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.service.ServiceContext;
022    
023    import com.liferay.portlet.softwarecatalog.model.SCProductEntry;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the s c product entry service.
029     *
030     * <p>
031     * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class.
032     * </p>
033     *
034     * @author Brian Wing Shun Chan
035     * @see SCProductEntryPersistence
036     * @see SCProductEntryPersistenceImpl
037     * @generated
038     */
039    public class SCProductEntryUtil {
040            /**
041             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
042             */
043            public static void clearCache() {
044                    getPersistence().clearCache();
045            }
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
049             */
050            public static void clearCache(SCProductEntry scProductEntry) {
051                    getPersistence().clearCache(scProductEntry);
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
056             */
057            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
058                    throws SystemException {
059                    return getPersistence().countWithDynamicQuery(dynamicQuery);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
064             */
065            public static List<SCProductEntry> findWithDynamicQuery(
066                    DynamicQuery dynamicQuery) throws SystemException {
067                    return getPersistence().findWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
072             */
073            public static List<SCProductEntry> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery, int start, int end)
075                    throws SystemException {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
081             */
082            public static List<SCProductEntry> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end,
084                    OrderByComparator orderByComparator) throws SystemException {
085                    return getPersistence()
086                                       .findWithDynamicQuery(dynamicQuery, start, end,
087                            orderByComparator);
088            }
089    
090            /**
091             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
092             */
093            public static SCProductEntry remove(SCProductEntry scProductEntry)
094                    throws SystemException {
095                    return getPersistence().remove(scProductEntry);
096            }
097    
098            /**
099             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
100             */
101            public static SCProductEntry update(SCProductEntry scProductEntry,
102                    boolean merge) throws SystemException {
103                    return getPersistence().update(scProductEntry, merge);
104            }
105    
106            /**
107             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
108             */
109            public static SCProductEntry update(SCProductEntry scProductEntry,
110                    boolean merge, ServiceContext serviceContext) throws SystemException {
111                    return getPersistence().update(scProductEntry, merge, serviceContext);
112            }
113    
114            /**
115            * Caches the s c product entry in the entity cache if it is enabled.
116            *
117            * @param scProductEntry the s c product entry to cache
118            */
119            public static void cacheResult(
120                    com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry) {
121                    getPersistence().cacheResult(scProductEntry);
122            }
123    
124            /**
125            * Caches the s c product entries in the entity cache if it is enabled.
126            *
127            * @param scProductEntries the s c product entries to cache
128            */
129            public static void cacheResult(
130                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) {
131                    getPersistence().cacheResult(scProductEntries);
132            }
133    
134            /**
135            * Creates a new s c product entry with the primary key.
136            *
137            * @param productEntryId the primary key for the new s c product entry
138            * @return the new s c product entry
139            */
140            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry create(
141                    long productEntryId) {
142                    return getPersistence().create(productEntryId);
143            }
144    
145            /**
146            * Removes the s c product entry with the primary key from the database. Also notifies the appropriate model listeners.
147            *
148            * @param productEntryId the primary key of the s c product entry to remove
149            * @return the s c product entry that was removed
150            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a s c product entry with the primary key could not be found
151            * @throws SystemException if a system exception occurred
152            */
153            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry remove(
154                    long productEntryId)
155                    throws com.liferay.portal.kernel.exception.SystemException,
156                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
157                    return getPersistence().remove(productEntryId);
158            }
159    
160            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry updateImpl(
161                    com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry,
162                    boolean merge)
163                    throws com.liferay.portal.kernel.exception.SystemException {
164                    return getPersistence().updateImpl(scProductEntry, merge);
165            }
166    
167            /**
168            * Finds the s c product entry with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchProductEntryException} if it could not be found.
169            *
170            * @param productEntryId the primary key of the s c product entry to find
171            * @return the s c product entry
172            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a s c product entry with the primary key could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByPrimaryKey(
176                    long productEntryId)
177                    throws com.liferay.portal.kernel.exception.SystemException,
178                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
179                    return getPersistence().findByPrimaryKey(productEntryId);
180            }
181    
182            /**
183            * Finds the s c product entry with the primary key or returns <code>null</code> if it could not be found.
184            *
185            * @param productEntryId the primary key of the s c product entry to find
186            * @return the s c product entry, or <code>null</code> if a s c product entry with the primary key could not be found
187            * @throws SystemException if a system exception occurred
188            */
189            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry fetchByPrimaryKey(
190                    long productEntryId)
191                    throws com.liferay.portal.kernel.exception.SystemException {
192                    return getPersistence().fetchByPrimaryKey(productEntryId);
193            }
194    
195            /**
196            * Finds all the s c product entries where groupId = &#63;.
197            *
198            * @param groupId the group id to search with
199            * @return the matching s c product entries
200            * @throws SystemException if a system exception occurred
201            */
202            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByGroupId(
203                    long groupId)
204                    throws com.liferay.portal.kernel.exception.SystemException {
205                    return getPersistence().findByGroupId(groupId);
206            }
207    
208            /**
209            * Finds a range of all the s c product entries where groupId = &#63;.
210            *
211            * <p>
212            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
213            * </p>
214            *
215            * @param groupId the group id to search with
216            * @param start the lower bound of the range of s c product entries to return
217            * @param end the upper bound of the range of s c product entries to return (not inclusive)
218            * @return the range of matching s c product entries
219            * @throws SystemException if a system exception occurred
220            */
221            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByGroupId(
222                    long groupId, int start, int end)
223                    throws com.liferay.portal.kernel.exception.SystemException {
224                    return getPersistence().findByGroupId(groupId, start, end);
225            }
226    
227            /**
228            * Finds an ordered range of all the s c product entries where groupId = &#63;.
229            *
230            * <p>
231            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
232            * </p>
233            *
234            * @param groupId the group id to search with
235            * @param start the lower bound of the range of s c product entries to return
236            * @param end the upper bound of the range of s c product entries to return (not inclusive)
237            * @param orderByComparator the comparator to order the results by
238            * @return the ordered range of matching s c product entries
239            * @throws SystemException if a system exception occurred
240            */
241            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByGroupId(
242                    long groupId, int start, int end,
243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
244                    throws com.liferay.portal.kernel.exception.SystemException {
245                    return getPersistence()
246                                       .findByGroupId(groupId, start, end, orderByComparator);
247            }
248    
249            /**
250            * Finds the first s c product entry in the ordered set where groupId = &#63;.
251            *
252            * <p>
253            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
254            * </p>
255            *
256            * @param groupId the group id to search with
257            * @param orderByComparator the comparator to order the set by
258            * @return the first matching s c product entry
259            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found
260            * @throws SystemException if a system exception occurred
261            */
262            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByGroupId_First(
263                    long groupId,
264                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
265                    throws com.liferay.portal.kernel.exception.SystemException,
266                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
267                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
268            }
269    
270            /**
271            * Finds the last s c product entry in the ordered set where groupId = &#63;.
272            *
273            * <p>
274            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
275            * </p>
276            *
277            * @param groupId the group id to search with
278            * @param orderByComparator the comparator to order the set by
279            * @return the last matching s c product entry
280            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found
281            * @throws SystemException if a system exception occurred
282            */
283            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByGroupId_Last(
284                    long groupId,
285                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
286                    throws com.liferay.portal.kernel.exception.SystemException,
287                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
288                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
289            }
290    
291            /**
292            * Finds the s c product entries before and after the current s c product entry in the ordered set where groupId = &#63;.
293            *
294            * <p>
295            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
296            * </p>
297            *
298            * @param productEntryId the primary key of the current s c product entry
299            * @param groupId the group id to search with
300            * @param orderByComparator the comparator to order the set by
301            * @return the previous, current, and next s c product entry
302            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a s c product entry with the primary key could not be found
303            * @throws SystemException if a system exception occurred
304            */
305            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry[] findByGroupId_PrevAndNext(
306                    long productEntryId, long groupId,
307                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
308                    throws com.liferay.portal.kernel.exception.SystemException,
309                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
310                    return getPersistence()
311                                       .findByGroupId_PrevAndNext(productEntryId, groupId,
312                            orderByComparator);
313            }
314    
315            /**
316            * Filters by the user's permissions and finds all the s c product entries where groupId = &#63;.
317            *
318            * @param groupId the group id to search with
319            * @return the matching s c product entries that the user has permission to view
320            * @throws SystemException if a system exception occurred
321            */
322            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> filterFindByGroupId(
323                    long groupId)
324                    throws com.liferay.portal.kernel.exception.SystemException {
325                    return getPersistence().filterFindByGroupId(groupId);
326            }
327    
328            /**
329            * Filters by the user's permissions and finds a range of all the s c product entries where groupId = &#63;.
330            *
331            * <p>
332            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
333            * </p>
334            *
335            * @param groupId the group id to search with
336            * @param start the lower bound of the range of s c product entries to return
337            * @param end the upper bound of the range of s c product entries to return (not inclusive)
338            * @return the range of matching s c product entries that the user has permission to view
339            * @throws SystemException if a system exception occurred
340            */
341            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> filterFindByGroupId(
342                    long groupId, int start, int end)
343                    throws com.liferay.portal.kernel.exception.SystemException {
344                    return getPersistence().filterFindByGroupId(groupId, start, end);
345            }
346    
347            /**
348            * Filters by the user's permissions and finds an ordered range of all the s c product entries where groupId = &#63;.
349            *
350            * <p>
351            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
352            * </p>
353            *
354            * @param groupId the group id to search with
355            * @param start the lower bound of the range of s c product entries to return
356            * @param end the upper bound of the range of s c product entries to return (not inclusive)
357            * @param orderByComparator the comparator to order the results by
358            * @return the ordered range of matching s c product entries that the user has permission to view
359            * @throws SystemException if a system exception occurred
360            */
361            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> filterFindByGroupId(
362                    long groupId, int start, int end,
363                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
364                    throws com.liferay.portal.kernel.exception.SystemException {
365                    return getPersistence()
366                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
367            }
368    
369            /**
370            * Finds all the s c product entries where companyId = &#63;.
371            *
372            * @param companyId the company id to search with
373            * @return the matching s c product entries
374            * @throws SystemException if a system exception occurred
375            */
376            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByCompanyId(
377                    long companyId)
378                    throws com.liferay.portal.kernel.exception.SystemException {
379                    return getPersistence().findByCompanyId(companyId);
380            }
381    
382            /**
383            * Finds a range of all the s c product entries where companyId = &#63;.
384            *
385            * <p>
386            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
387            * </p>
388            *
389            * @param companyId the company id to search with
390            * @param start the lower bound of the range of s c product entries to return
391            * @param end the upper bound of the range of s c product entries to return (not inclusive)
392            * @return the range of matching s c product entries
393            * @throws SystemException if a system exception occurred
394            */
395            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByCompanyId(
396                    long companyId, int start, int end)
397                    throws com.liferay.portal.kernel.exception.SystemException {
398                    return getPersistence().findByCompanyId(companyId, start, end);
399            }
400    
401            /**
402            * Finds an ordered range of all the s c product entries where companyId = &#63;.
403            *
404            * <p>
405            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
406            * </p>
407            *
408            * @param companyId the company id to search with
409            * @param start the lower bound of the range of s c product entries to return
410            * @param end the upper bound of the range of s c product entries to return (not inclusive)
411            * @param orderByComparator the comparator to order the results by
412            * @return the ordered range of matching s c product entries
413            * @throws SystemException if a system exception occurred
414            */
415            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByCompanyId(
416                    long companyId, int start, int end,
417                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
418                    throws com.liferay.portal.kernel.exception.SystemException {
419                    return getPersistence()
420                                       .findByCompanyId(companyId, start, end, orderByComparator);
421            }
422    
423            /**
424            * Finds the first s c product entry in the ordered set where companyId = &#63;.
425            *
426            * <p>
427            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
428            * </p>
429            *
430            * @param companyId the company id to search with
431            * @param orderByComparator the comparator to order the set by
432            * @return the first matching s c product entry
433            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found
434            * @throws SystemException if a system exception occurred
435            */
436            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByCompanyId_First(
437                    long companyId,
438                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
439                    throws com.liferay.portal.kernel.exception.SystemException,
440                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
441                    return getPersistence()
442                                       .findByCompanyId_First(companyId, orderByComparator);
443            }
444    
445            /**
446            * Finds the last s c product entry in the ordered set where companyId = &#63;.
447            *
448            * <p>
449            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
450            * </p>
451            *
452            * @param companyId the company id to search with
453            * @param orderByComparator the comparator to order the set by
454            * @return the last matching s c product entry
455            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found
456            * @throws SystemException if a system exception occurred
457            */
458            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByCompanyId_Last(
459                    long companyId,
460                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
461                    throws com.liferay.portal.kernel.exception.SystemException,
462                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
463                    return getPersistence()
464                                       .findByCompanyId_Last(companyId, orderByComparator);
465            }
466    
467            /**
468            * Finds the s c product entries before and after the current s c product entry in the ordered set where companyId = &#63;.
469            *
470            * <p>
471            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
472            * </p>
473            *
474            * @param productEntryId the primary key of the current s c product entry
475            * @param companyId the company id to search with
476            * @param orderByComparator the comparator to order the set by
477            * @return the previous, current, and next s c product entry
478            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a s c product entry with the primary key could not be found
479            * @throws SystemException if a system exception occurred
480            */
481            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry[] findByCompanyId_PrevAndNext(
482                    long productEntryId, long companyId,
483                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
484                    throws com.liferay.portal.kernel.exception.SystemException,
485                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
486                    return getPersistence()
487                                       .findByCompanyId_PrevAndNext(productEntryId, companyId,
488                            orderByComparator);
489            }
490    
491            /**
492            * Finds all the s c product entries where groupId = &#63; and userId = &#63;.
493            *
494            * @param groupId the group id to search with
495            * @param userId the user id to search with
496            * @return the matching s c product entries
497            * @throws SystemException if a system exception occurred
498            */
499            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByG_U(
500                    long groupId, long userId)
501                    throws com.liferay.portal.kernel.exception.SystemException {
502                    return getPersistence().findByG_U(groupId, userId);
503            }
504    
505            /**
506            * Finds a range of all the s c product entries 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
510            * </p>
511            *
512            * @param groupId the group id to search with
513            * @param userId the user id to search with
514            * @param start the lower bound of the range of s c product entries to return
515            * @param end the upper bound of the range of s c product entries to return (not inclusive)
516            * @return the range of matching s c product entries
517            * @throws SystemException if a system exception occurred
518            */
519            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByG_U(
520                    long groupId, long userId, int start, int end)
521                    throws com.liferay.portal.kernel.exception.SystemException {
522                    return getPersistence().findByG_U(groupId, userId, start, end);
523            }
524    
525            /**
526            * Finds an ordered range of all the s c product entries where groupId = &#63; and userId = &#63;.
527            *
528            * <p>
529            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
530            * </p>
531            *
532            * @param groupId the group id to search with
533            * @param userId the user id to search with
534            * @param start the lower bound of the range of s c product entries to return
535            * @param end the upper bound of the range of s c product entries to return (not inclusive)
536            * @param orderByComparator the comparator to order the results by
537            * @return the ordered range of matching s c product entries
538            * @throws SystemException if a system exception occurred
539            */
540            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByG_U(
541                    long groupId, long userId, int start, int end,
542                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
543                    throws com.liferay.portal.kernel.exception.SystemException {
544                    return getPersistence()
545                                       .findByG_U(groupId, userId, start, end, orderByComparator);
546            }
547    
548            /**
549            * Finds the first s c product entry in the ordered set where groupId = &#63; and userId = &#63;.
550            *
551            * <p>
552            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
553            * </p>
554            *
555            * @param groupId the group id to search with
556            * @param userId the user id to search with
557            * @param orderByComparator the comparator to order the set by
558            * @return the first matching s c product entry
559            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found
560            * @throws SystemException if a system exception occurred
561            */
562            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByG_U_First(
563                    long groupId, long userId,
564                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
565                    throws com.liferay.portal.kernel.exception.SystemException,
566                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
567                    return getPersistence()
568                                       .findByG_U_First(groupId, userId, orderByComparator);
569            }
570    
571            /**
572            * Finds the last s c product entry in the ordered set where groupId = &#63; and userId = &#63;.
573            *
574            * <p>
575            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
576            * </p>
577            *
578            * @param groupId the group id to search with
579            * @param userId the user id to search with
580            * @param orderByComparator the comparator to order the set by
581            * @return the last matching s c product entry
582            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found
583            * @throws SystemException if a system exception occurred
584            */
585            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByG_U_Last(
586                    long groupId, long userId,
587                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
588                    throws com.liferay.portal.kernel.exception.SystemException,
589                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
590                    return getPersistence()
591                                       .findByG_U_Last(groupId, userId, orderByComparator);
592            }
593    
594            /**
595            * Finds the s c product entries before and after the current s c product entry in the ordered set where groupId = &#63; and userId = &#63;.
596            *
597            * <p>
598            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
599            * </p>
600            *
601            * @param productEntryId the primary key of the current s c product entry
602            * @param groupId the group id to search with
603            * @param userId the user id to search with
604            * @param orderByComparator the comparator to order the set by
605            * @return the previous, current, and next s c product entry
606            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a s c product entry with the primary key could not be found
607            * @throws SystemException if a system exception occurred
608            */
609            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry[] findByG_U_PrevAndNext(
610                    long productEntryId, long groupId, long userId,
611                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
612                    throws com.liferay.portal.kernel.exception.SystemException,
613                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
614                    return getPersistence()
615                                       .findByG_U_PrevAndNext(productEntryId, groupId, userId,
616                            orderByComparator);
617            }
618    
619            /**
620            * Filters by the user's permissions and finds all the s c product entries where groupId = &#63; and userId = &#63;.
621            *
622            * @param groupId the group id to search with
623            * @param userId the user id to search with
624            * @return the matching s c product entries that the user has permission to view
625            * @throws SystemException if a system exception occurred
626            */
627            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> filterFindByG_U(
628                    long groupId, long userId)
629                    throws com.liferay.portal.kernel.exception.SystemException {
630                    return getPersistence().filterFindByG_U(groupId, userId);
631            }
632    
633            /**
634            * Filters by the user's permissions and finds a range of all the s c product entries where groupId = &#63; and userId = &#63;.
635            *
636            * <p>
637            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
638            * </p>
639            *
640            * @param groupId the group id to search with
641            * @param userId the user id to search with
642            * @param start the lower bound of the range of s c product entries to return
643            * @param end the upper bound of the range of s c product entries to return (not inclusive)
644            * @return the range of matching s c product entries that the user has permission to view
645            * @throws SystemException if a system exception occurred
646            */
647            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> filterFindByG_U(
648                    long groupId, long userId, int start, int end)
649                    throws com.liferay.portal.kernel.exception.SystemException {
650                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
651            }
652    
653            /**
654            * Filters by the user's permissions and finds an ordered range of all the s c product entries where groupId = &#63; and userId = &#63;.
655            *
656            * <p>
657            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
658            * </p>
659            *
660            * @param groupId the group id to search with
661            * @param userId the user id to search with
662            * @param start the lower bound of the range of s c product entries to return
663            * @param end the upper bound of the range of s c product entries to return (not inclusive)
664            * @param orderByComparator the comparator to order the results by
665            * @return the ordered range of matching s c product entries that the user has permission to view
666            * @throws SystemException if a system exception occurred
667            */
668            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> filterFindByG_U(
669                    long groupId, long userId, int start, int end,
670                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
671                    throws com.liferay.portal.kernel.exception.SystemException {
672                    return getPersistence()
673                                       .filterFindByG_U(groupId, userId, start, end,
674                            orderByComparator);
675            }
676    
677            /**
678            * Finds the s c product entry where repoGroupId = &#63; and repoArtifactId = &#63; or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchProductEntryException} if it could not be found.
679            *
680            * @param repoGroupId the repo group id to search with
681            * @param repoArtifactId the repo artifact id to search with
682            * @return the matching s c product entry
683            * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found
684            * @throws SystemException if a system exception occurred
685            */
686            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByRG_RA(
687                    java.lang.String repoGroupId, java.lang.String repoArtifactId)
688                    throws com.liferay.portal.kernel.exception.SystemException,
689                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
690                    return getPersistence().findByRG_RA(repoGroupId, repoArtifactId);
691            }
692    
693            /**
694            * Finds 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.
695            *
696            * @param repoGroupId the repo group id to search with
697            * @param repoArtifactId the repo artifact id to search with
698            * @return the matching s c product entry, or <code>null</code> if a matching s c product entry could not be found
699            * @throws SystemException if a system exception occurred
700            */
701            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry fetchByRG_RA(
702                    java.lang.String repoGroupId, java.lang.String repoArtifactId)
703                    throws com.liferay.portal.kernel.exception.SystemException {
704                    return getPersistence().fetchByRG_RA(repoGroupId, repoArtifactId);
705            }
706    
707            /**
708            * Finds 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.
709            *
710            * @param repoGroupId the repo group id to search with
711            * @param repoArtifactId the repo artifact id to search with
712            * @return the matching s c product entry, or <code>null</code> if a matching s c product entry could not be found
713            * @throws SystemException if a system exception occurred
714            */
715            public static com.liferay.portlet.softwarecatalog.model.SCProductEntry fetchByRG_RA(
716                    java.lang.String repoGroupId, java.lang.String repoArtifactId,
717                    boolean retrieveFromCache)
718                    throws com.liferay.portal.kernel.exception.SystemException {
719                    return getPersistence()
720                                       .fetchByRG_RA(repoGroupId, repoArtifactId, retrieveFromCache);
721            }
722    
723            /**
724            * Finds all the s c product entries.
725            *
726            * @return the s c product entries
727            * @throws SystemException if a system exception occurred
728            */
729            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findAll()
730                    throws com.liferay.portal.kernel.exception.SystemException {
731                    return getPersistence().findAll();
732            }
733    
734            /**
735            * Finds a range of all the s c product entries.
736            *
737            * <p>
738            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
739            * </p>
740            *
741            * @param start the lower bound of the range of s c product entries to return
742            * @param end the upper bound of the range of s c product entries to return (not inclusive)
743            * @return the range of s c product entries
744            * @throws SystemException if a system exception occurred
745            */
746            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findAll(
747                    int start, int end)
748                    throws com.liferay.portal.kernel.exception.SystemException {
749                    return getPersistence().findAll(start, end);
750            }
751    
752            /**
753            * Finds an ordered range of all the s c product entries.
754            *
755            * <p>
756            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
757            * </p>
758            *
759            * @param start the lower bound of the range of s c product entries to return
760            * @param end the upper bound of the range of s c product entries to return (not inclusive)
761            * @param orderByComparator the comparator to order the results by
762            * @return the ordered range of s c product entries
763            * @throws SystemException if a system exception occurred
764            */
765            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findAll(
766                    int start, int end,
767                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
768                    throws com.liferay.portal.kernel.exception.SystemException {
769                    return getPersistence().findAll(start, end, orderByComparator);
770            }
771    
772            /**
773            * Removes all the s c product entries where groupId = &#63; from the database.
774            *
775            * @param groupId the group id to search with
776            * @throws SystemException if a system exception occurred
777            */
778            public static void removeByGroupId(long groupId)
779                    throws com.liferay.portal.kernel.exception.SystemException {
780                    getPersistence().removeByGroupId(groupId);
781            }
782    
783            /**
784            * Removes all the s c product entries where companyId = &#63; from the database.
785            *
786            * @param companyId the company id to search with
787            * @throws SystemException if a system exception occurred
788            */
789            public static void removeByCompanyId(long companyId)
790                    throws com.liferay.portal.kernel.exception.SystemException {
791                    getPersistence().removeByCompanyId(companyId);
792            }
793    
794            /**
795            * Removes all the s c product entries where groupId = &#63; and userId = &#63; from the database.
796            *
797            * @param groupId the group id to search with
798            * @param userId the user id to search with
799            * @throws SystemException if a system exception occurred
800            */
801            public static void removeByG_U(long groupId, long userId)
802                    throws com.liferay.portal.kernel.exception.SystemException {
803                    getPersistence().removeByG_U(groupId, userId);
804            }
805    
806            /**
807            * Removes the s c product entry where repoGroupId = &#63; and repoArtifactId = &#63; from the database.
808            *
809            * @param repoGroupId the repo group id to search with
810            * @param repoArtifactId the repo artifact id to search with
811            * @throws SystemException if a system exception occurred
812            */
813            public static void removeByRG_RA(java.lang.String repoGroupId,
814                    java.lang.String repoArtifactId)
815                    throws com.liferay.portal.kernel.exception.SystemException,
816                            com.liferay.portlet.softwarecatalog.NoSuchProductEntryException {
817                    getPersistence().removeByRG_RA(repoGroupId, repoArtifactId);
818            }
819    
820            /**
821            * Removes all the s c product entries from the database.
822            *
823            * @throws SystemException if a system exception occurred
824            */
825            public static void removeAll()
826                    throws com.liferay.portal.kernel.exception.SystemException {
827                    getPersistence().removeAll();
828            }
829    
830            /**
831            * Counts all the s c product entries where groupId = &#63;.
832            *
833            * @param groupId the group id to search with
834            * @return the number of matching s c product entries
835            * @throws SystemException if a system exception occurred
836            */
837            public static int countByGroupId(long groupId)
838                    throws com.liferay.portal.kernel.exception.SystemException {
839                    return getPersistence().countByGroupId(groupId);
840            }
841    
842            /**
843            * Filters by the user's permissions and counts all the s c product entries where groupId = &#63;.
844            *
845            * @param groupId the group id to search with
846            * @return the number of matching s c product entries that the user has permission to view
847            * @throws SystemException if a system exception occurred
848            */
849            public static int filterCountByGroupId(long groupId)
850                    throws com.liferay.portal.kernel.exception.SystemException {
851                    return getPersistence().filterCountByGroupId(groupId);
852            }
853    
854            /**
855            * Counts all the s c product entries where companyId = &#63;.
856            *
857            * @param companyId the company id to search with
858            * @return the number of matching s c product entries
859            * @throws SystemException if a system exception occurred
860            */
861            public static int countByCompanyId(long companyId)
862                    throws com.liferay.portal.kernel.exception.SystemException {
863                    return getPersistence().countByCompanyId(companyId);
864            }
865    
866            /**
867            * Counts all the s c product entries where groupId = &#63; and userId = &#63;.
868            *
869            * @param groupId the group id to search with
870            * @param userId the user id to search with
871            * @return the number of matching s c product entries
872            * @throws SystemException if a system exception occurred
873            */
874            public static int countByG_U(long groupId, long userId)
875                    throws com.liferay.portal.kernel.exception.SystemException {
876                    return getPersistence().countByG_U(groupId, userId);
877            }
878    
879            /**
880            * Filters by the user's permissions and counts all the s c product entries where groupId = &#63; and userId = &#63;.
881            *
882            * @param groupId the group id to search with
883            * @param userId the user id to search with
884            * @return the number of matching s c product entries that the user has permission to view
885            * @throws SystemException if a system exception occurred
886            */
887            public static int filterCountByG_U(long groupId, long userId)
888                    throws com.liferay.portal.kernel.exception.SystemException {
889                    return getPersistence().filterCountByG_U(groupId, userId);
890            }
891    
892            /**
893            * Counts all the s c product entries where repoGroupId = &#63; and repoArtifactId = &#63;.
894            *
895            * @param repoGroupId the repo group id to search with
896            * @param repoArtifactId the repo artifact id to search with
897            * @return the number of matching s c product entries
898            * @throws SystemException if a system exception occurred
899            */
900            public static int countByRG_RA(java.lang.String repoGroupId,
901                    java.lang.String repoArtifactId)
902                    throws com.liferay.portal.kernel.exception.SystemException {
903                    return getPersistence().countByRG_RA(repoGroupId, repoArtifactId);
904            }
905    
906            /**
907            * Counts all the s c product entries.
908            *
909            * @return the number of s c product entries
910            * @throws SystemException if a system exception occurred
911            */
912            public static int countAll()
913                    throws com.liferay.portal.kernel.exception.SystemException {
914                    return getPersistence().countAll();
915            }
916    
917            /**
918            * Gets all the s c licenses associated with the s c product entry.
919            *
920            * @param pk the primary key of the s c product entry to get the associated s c licenses for
921            * @return the s c licenses associated with the s c product entry
922            * @throws SystemException if a system exception occurred
923            */
924            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses(
925                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
926                    return getPersistence().getSCLicenses(pk);
927            }
928    
929            /**
930            * Gets a range of all the s c licenses associated with the s c product entry.
931            *
932            * <p>
933            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
934            * </p>
935            *
936            * @param pk the primary key of the s c product entry to get the associated s c licenses for
937            * @param start the lower bound of the range of s c product entries to return
938            * @param end the upper bound of the range of s c product entries to return (not inclusive)
939            * @return the range of s c licenses associated with the s c product entry
940            * @throws SystemException if a system exception occurred
941            */
942            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses(
943                    long pk, int start, int end)
944                    throws com.liferay.portal.kernel.exception.SystemException {
945                    return getPersistence().getSCLicenses(pk, start, end);
946            }
947    
948            /**
949            * Gets an ordered range of all the s c licenses associated with the s c product entry.
950            *
951            * <p>
952            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
953            * </p>
954            *
955            * @param pk the primary key of the s c product entry to get the associated s c licenses for
956            * @param start the lower bound of the range of s c product entries to return
957            * @param end the upper bound of the range of s c product entries to return (not inclusive)
958            * @param orderByComparator the comparator to order the results by
959            * @return the ordered range of s c licenses associated with the s c product entry
960            * @throws SystemException if a system exception occurred
961            */
962            public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses(
963                    long pk, int start, int end,
964                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
965                    throws com.liferay.portal.kernel.exception.SystemException {
966                    return getPersistence().getSCLicenses(pk, start, end, orderByComparator);
967            }
968    
969            /**
970            * Gets the number of s c licenses associated with the s c product entry.
971            *
972            * @param pk the primary key of the s c product entry to get the number of associated s c licenses for
973            * @return the number of s c licenses associated with the s c product entry
974            * @throws SystemException if a system exception occurred
975            */
976            public static int getSCLicensesSize(long pk)
977                    throws com.liferay.portal.kernel.exception.SystemException {
978                    return getPersistence().getSCLicensesSize(pk);
979            }
980    
981            /**
982            * Determines whether the s c license is associated with the s c product entry.
983            *
984            * @param pk the primary key of the s c product entry
985            * @param scLicensePK the primary key of the s c license
986            * @return whether the s c license is associated with the s c product entry
987            * @throws SystemException if a system exception occurred
988            */
989            public static boolean containsSCLicense(long pk, long scLicensePK)
990                    throws com.liferay.portal.kernel.exception.SystemException {
991                    return getPersistence().containsSCLicense(pk, scLicensePK);
992            }
993    
994            /**
995            * Determines whether the s c product entry has any s c licenses associated with it.
996            *
997            * @param pk the primary key of the s c product entry to check for associations with s c licenses
998            * @return whether the s c product entry has any s c licenses associated with it
999            * @throws SystemException if a system exception occurred
1000            */
1001            public static boolean containsSCLicenses(long pk)
1002                    throws com.liferay.portal.kernel.exception.SystemException {
1003                    return getPersistence().containsSCLicenses(pk);
1004            }
1005    
1006            /**
1007            * 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.
1008            *
1009            * @param pk the primary key of the s c product entry
1010            * @param scLicensePK the primary key of the s c license
1011            * @throws SystemException if a system exception occurred
1012            */
1013            public static void addSCLicense(long pk, long scLicensePK)
1014                    throws com.liferay.portal.kernel.exception.SystemException {
1015                    getPersistence().addSCLicense(pk, scLicensePK);
1016            }
1017    
1018            /**
1019            * 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.
1020            *
1021            * @param pk the primary key of the s c product entry
1022            * @param scLicense the s c license
1023            * @throws SystemException if a system exception occurred
1024            */
1025            public static void addSCLicense(long pk,
1026                    com.liferay.portlet.softwarecatalog.model.SCLicense scLicense)
1027                    throws com.liferay.portal.kernel.exception.SystemException {
1028                    getPersistence().addSCLicense(pk, scLicense);
1029            }
1030    
1031            /**
1032            * 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.
1033            *
1034            * @param pk the primary key of the s c product entry
1035            * @param scLicensePKs the primary keys of the s c licenses
1036            * @throws SystemException if a system exception occurred
1037            */
1038            public static void addSCLicenses(long pk, long[] scLicensePKs)
1039                    throws com.liferay.portal.kernel.exception.SystemException {
1040                    getPersistence().addSCLicenses(pk, scLicensePKs);
1041            }
1042    
1043            /**
1044            * 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.
1045            *
1046            * @param pk the primary key of the s c product entry
1047            * @param scLicenses the s c licenses
1048            * @throws SystemException if a system exception occurred
1049            */
1050            public static void addSCLicenses(long pk,
1051                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses)
1052                    throws com.liferay.portal.kernel.exception.SystemException {
1053                    getPersistence().addSCLicenses(pk, scLicenses);
1054            }
1055    
1056            /**
1057            * 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.
1058            *
1059            * @param pk the primary key of the s c product entry to clear the associated s c licenses from
1060            * @throws SystemException if a system exception occurred
1061            */
1062            public static void clearSCLicenses(long pk)
1063                    throws com.liferay.portal.kernel.exception.SystemException {
1064                    getPersistence().clearSCLicenses(pk);
1065            }
1066    
1067            /**
1068            * 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.
1069            *
1070            * @param pk the primary key of the s c product entry
1071            * @param scLicensePK the primary key of the s c license
1072            * @throws SystemException if a system exception occurred
1073            */
1074            public static void removeSCLicense(long pk, long scLicensePK)
1075                    throws com.liferay.portal.kernel.exception.SystemException {
1076                    getPersistence().removeSCLicense(pk, scLicensePK);
1077            }
1078    
1079            /**
1080            * 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.
1081            *
1082            * @param pk the primary key of the s c product entry
1083            * @param scLicense the s c license
1084            * @throws SystemException if a system exception occurred
1085            */
1086            public static void removeSCLicense(long pk,
1087                    com.liferay.portlet.softwarecatalog.model.SCLicense scLicense)
1088                    throws com.liferay.portal.kernel.exception.SystemException {
1089                    getPersistence().removeSCLicense(pk, scLicense);
1090            }
1091    
1092            /**
1093            * 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.
1094            *
1095            * @param pk the primary key of the s c product entry
1096            * @param scLicensePKs the primary keys of the s c licenses
1097            * @throws SystemException if a system exception occurred
1098            */
1099            public static void removeSCLicenses(long pk, long[] scLicensePKs)
1100                    throws com.liferay.portal.kernel.exception.SystemException {
1101                    getPersistence().removeSCLicenses(pk, scLicensePKs);
1102            }
1103    
1104            /**
1105            * 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.
1106            *
1107            * @param pk the primary key of the s c product entry
1108            * @param scLicenses the s c licenses
1109            * @throws SystemException if a system exception occurred
1110            */
1111            public static void removeSCLicenses(long pk,
1112                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses)
1113                    throws com.liferay.portal.kernel.exception.SystemException {
1114                    getPersistence().removeSCLicenses(pk, scLicenses);
1115            }
1116    
1117            /**
1118            * 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.
1119            *
1120            * @param pk the primary key of the s c product entry to set the associations for
1121            * @param scLicensePKs the primary keys of the s c licenses to be associated with the s c product entry
1122            * @throws SystemException if a system exception occurred
1123            */
1124            public static void setSCLicenses(long pk, long[] scLicensePKs)
1125                    throws com.liferay.portal.kernel.exception.SystemException {
1126                    getPersistence().setSCLicenses(pk, scLicensePKs);
1127            }
1128    
1129            /**
1130            * 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.
1131            *
1132            * @param pk the primary key of the s c product entry to set the associations for
1133            * @param scLicenses the s c licenses to be associated with the s c product entry
1134            * @throws SystemException if a system exception occurred
1135            */
1136            public static void setSCLicenses(long pk,
1137                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses)
1138                    throws com.liferay.portal.kernel.exception.SystemException {
1139                    getPersistence().setSCLicenses(pk, scLicenses);
1140            }
1141    
1142            public static SCProductEntryPersistence getPersistence() {
1143                    if (_persistence == null) {
1144                            _persistence = (SCProductEntryPersistence)PortalBeanLocatorUtil.locate(SCProductEntryPersistence.class.getName());
1145                    }
1146    
1147                    return _persistence;
1148            }
1149    
1150            public void setPersistence(SCProductEntryPersistence persistence) {
1151                    _persistence = persistence;
1152            }
1153    
1154            private static SCProductEntryPersistence _persistence;
1155    }