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