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