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