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