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