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