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