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