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