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