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.social.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.social.model.SocialActivitySet;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the social activity set service. This utility wraps {@link com.liferay.portlet.social.service.persistence.impl.SocialActivitySetPersistenceImpl} 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 SocialActivitySetPersistence
038     * @see com.liferay.portlet.social.service.persistence.impl.SocialActivitySetPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class SocialActivitySetUtil {
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(SocialActivitySet socialActivitySet) {
060                    getPersistence().clearCache(socialActivitySet);
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<SocialActivitySet> 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<SocialActivitySet> 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<SocialActivitySet> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<SocialActivitySet> 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 SocialActivitySet update(SocialActivitySet socialActivitySet) {
101                    return getPersistence().update(socialActivitySet);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static SocialActivitySet update(
108                    SocialActivitySet socialActivitySet, ServiceContext serviceContext) {
109                    return getPersistence().update(socialActivitySet, serviceContext);
110            }
111    
112            /**
113            * Returns all the social activity sets where groupId = &#63;.
114            *
115            * @param groupId the group ID
116            * @return the matching social activity sets
117            */
118            public static List<SocialActivitySet> findByGroupId(long groupId) {
119                    return getPersistence().findByGroupId(groupId);
120            }
121    
122            /**
123            * Returns a range of all the social activity sets 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 SocialActivitySetModelImpl}. 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 social activity sets
131            * @param end the upper bound of the range of social activity sets (not inclusive)
132            * @return the range of matching social activity sets
133            */
134            public static List<SocialActivitySet> findByGroupId(long groupId,
135                    int start, int end) {
136                    return getPersistence().findByGroupId(groupId, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the social activity sets 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 SocialActivitySetModelImpl}. 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 social activity sets
148            * @param end the upper bound of the range of social activity sets (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching social activity sets
151            */
152            public static List<SocialActivitySet> findByGroupId(long groupId,
153                    int start, int end,
154                    OrderByComparator<SocialActivitySet> orderByComparator) {
155                    return getPersistence()
156                                       .findByGroupId(groupId, start, end, orderByComparator);
157            }
158    
159            /**
160            * Returns an ordered range of all the social activity sets where groupId = &#63;.
161            *
162            * <p>
163            * 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 SocialActivitySetModelImpl}. 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.
164            * </p>
165            *
166            * @param groupId the group ID
167            * @param start the lower bound of the range of social activity sets
168            * @param end the upper bound of the range of social activity sets (not inclusive)
169            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
170            * @param retrieveFromCache whether to retrieve from the finder cache
171            * @return the ordered range of matching social activity sets
172            */
173            public static List<SocialActivitySet> findByGroupId(long groupId,
174                    int start, int end,
175                    OrderByComparator<SocialActivitySet> orderByComparator,
176                    boolean retrieveFromCache) {
177                    return getPersistence()
178                                       .findByGroupId(groupId, start, end, orderByComparator,
179                            retrieveFromCache);
180            }
181    
182            /**
183            * Returns the first social activity set in the ordered set where groupId = &#63;.
184            *
185            * @param groupId the group ID
186            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
187            * @return the first matching social activity set
188            * @throws NoSuchActivitySetException if a matching social activity set could not be found
189            */
190            public static SocialActivitySet findByGroupId_First(long groupId,
191                    OrderByComparator<SocialActivitySet> orderByComparator)
192                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
193                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
194            }
195    
196            /**
197            * Returns the first social activity set in the ordered set where groupId = &#63;.
198            *
199            * @param groupId the group ID
200            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
201            * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found
202            */
203            public static SocialActivitySet fetchByGroupId_First(long groupId,
204                    OrderByComparator<SocialActivitySet> orderByComparator) {
205                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
206            }
207    
208            /**
209            * Returns the last social activity set in the ordered set where groupId = &#63;.
210            *
211            * @param groupId the group ID
212            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
213            * @return the last matching social activity set
214            * @throws NoSuchActivitySetException if a matching social activity set could not be found
215            */
216            public static SocialActivitySet findByGroupId_Last(long groupId,
217                    OrderByComparator<SocialActivitySet> orderByComparator)
218                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
219                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
220            }
221    
222            /**
223            * Returns the last social activity set in the ordered set where groupId = &#63;.
224            *
225            * @param groupId the group ID
226            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
227            * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found
228            */
229            public static SocialActivitySet fetchByGroupId_Last(long groupId,
230                    OrderByComparator<SocialActivitySet> orderByComparator) {
231                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
232            }
233    
234            /**
235            * Returns the social activity sets before and after the current social activity set in the ordered set where groupId = &#63;.
236            *
237            * @param activitySetId the primary key of the current social activity set
238            * @param groupId the group ID
239            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
240            * @return the previous, current, and next social activity set
241            * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found
242            */
243            public static SocialActivitySet[] findByGroupId_PrevAndNext(
244                    long activitySetId, long groupId,
245                    OrderByComparator<SocialActivitySet> orderByComparator)
246                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
247                    return getPersistence()
248                                       .findByGroupId_PrevAndNext(activitySetId, groupId,
249                            orderByComparator);
250            }
251    
252            /**
253            * Removes all the social activity sets where groupId = &#63; from the database.
254            *
255            * @param groupId the group ID
256            */
257            public static void removeByGroupId(long groupId) {
258                    getPersistence().removeByGroupId(groupId);
259            }
260    
261            /**
262            * Returns the number of social activity sets where groupId = &#63;.
263            *
264            * @param groupId the group ID
265            * @return the number of matching social activity sets
266            */
267            public static int countByGroupId(long groupId) {
268                    return getPersistence().countByGroupId(groupId);
269            }
270    
271            /**
272            * Returns all the social activity sets where userId = &#63;.
273            *
274            * @param userId the user ID
275            * @return the matching social activity sets
276            */
277            public static List<SocialActivitySet> findByUserId(long userId) {
278                    return getPersistence().findByUserId(userId);
279            }
280    
281            /**
282            * Returns a range of all the social activity sets where userId = &#63;.
283            *
284            * <p>
285            * 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 SocialActivitySetModelImpl}. 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.
286            * </p>
287            *
288            * @param userId the user ID
289            * @param start the lower bound of the range of social activity sets
290            * @param end the upper bound of the range of social activity sets (not inclusive)
291            * @return the range of matching social activity sets
292            */
293            public static List<SocialActivitySet> findByUserId(long userId, int start,
294                    int end) {
295                    return getPersistence().findByUserId(userId, start, end);
296            }
297    
298            /**
299            * Returns an ordered range of all the social activity sets where userId = &#63;.
300            *
301            * <p>
302            * 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 SocialActivitySetModelImpl}. 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.
303            * </p>
304            *
305            * @param userId the user ID
306            * @param start the lower bound of the range of social activity sets
307            * @param end the upper bound of the range of social activity sets (not inclusive)
308            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
309            * @return the ordered range of matching social activity sets
310            */
311            public static List<SocialActivitySet> findByUserId(long userId, int start,
312                    int end, OrderByComparator<SocialActivitySet> orderByComparator) {
313                    return getPersistence()
314                                       .findByUserId(userId, start, end, orderByComparator);
315            }
316    
317            /**
318            * Returns an ordered range of all the social activity sets where userId = &#63;.
319            *
320            * <p>
321            * 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 SocialActivitySetModelImpl}. 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.
322            * </p>
323            *
324            * @param userId the user ID
325            * @param start the lower bound of the range of social activity sets
326            * @param end the upper bound of the range of social activity sets (not inclusive)
327            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
328            * @param retrieveFromCache whether to retrieve from the finder cache
329            * @return the ordered range of matching social activity sets
330            */
331            public static List<SocialActivitySet> findByUserId(long userId, int start,
332                    int end, OrderByComparator<SocialActivitySet> orderByComparator,
333                    boolean retrieveFromCache) {
334                    return getPersistence()
335                                       .findByUserId(userId, start, end, orderByComparator,
336                            retrieveFromCache);
337            }
338    
339            /**
340            * Returns the first social activity set in the ordered set where userId = &#63;.
341            *
342            * @param userId the user ID
343            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
344            * @return the first matching social activity set
345            * @throws NoSuchActivitySetException if a matching social activity set could not be found
346            */
347            public static SocialActivitySet findByUserId_First(long userId,
348                    OrderByComparator<SocialActivitySet> orderByComparator)
349                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
350                    return getPersistence().findByUserId_First(userId, orderByComparator);
351            }
352    
353            /**
354            * Returns the first social activity set in the ordered set where userId = &#63;.
355            *
356            * @param userId the user ID
357            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
358            * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found
359            */
360            public static SocialActivitySet fetchByUserId_First(long userId,
361                    OrderByComparator<SocialActivitySet> orderByComparator) {
362                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
363            }
364    
365            /**
366            * Returns the last social activity set in the ordered set where userId = &#63;.
367            *
368            * @param userId the user ID
369            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
370            * @return the last matching social activity set
371            * @throws NoSuchActivitySetException if a matching social activity set could not be found
372            */
373            public static SocialActivitySet findByUserId_Last(long userId,
374                    OrderByComparator<SocialActivitySet> orderByComparator)
375                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
376                    return getPersistence().findByUserId_Last(userId, orderByComparator);
377            }
378    
379            /**
380            * Returns the last social activity set in the ordered set where userId = &#63;.
381            *
382            * @param userId the user ID
383            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
384            * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found
385            */
386            public static SocialActivitySet fetchByUserId_Last(long userId,
387                    OrderByComparator<SocialActivitySet> orderByComparator) {
388                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
389            }
390    
391            /**
392            * Returns the social activity sets before and after the current social activity set in the ordered set where userId = &#63;.
393            *
394            * @param activitySetId the primary key of the current social activity set
395            * @param userId the user ID
396            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
397            * @return the previous, current, and next social activity set
398            * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found
399            */
400            public static SocialActivitySet[] findByUserId_PrevAndNext(
401                    long activitySetId, long userId,
402                    OrderByComparator<SocialActivitySet> orderByComparator)
403                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
404                    return getPersistence()
405                                       .findByUserId_PrevAndNext(activitySetId, userId,
406                            orderByComparator);
407            }
408    
409            /**
410            * Removes all the social activity sets where userId = &#63; from the database.
411            *
412            * @param userId the user ID
413            */
414            public static void removeByUserId(long userId) {
415                    getPersistence().removeByUserId(userId);
416            }
417    
418            /**
419            * Returns the number of social activity sets where userId = &#63;.
420            *
421            * @param userId the user ID
422            * @return the number of matching social activity sets
423            */
424            public static int countByUserId(long userId) {
425                    return getPersistence().countByUserId(userId);
426            }
427    
428            /**
429            * Returns all the social activity sets where groupId = &#63; and userId = &#63; and type = &#63;.
430            *
431            * @param groupId the group ID
432            * @param userId the user ID
433            * @param type the type
434            * @return the matching social activity sets
435            */
436            public static List<SocialActivitySet> findByG_U_T(long groupId,
437                    long userId, int type) {
438                    return getPersistence().findByG_U_T(groupId, userId, type);
439            }
440    
441            /**
442            * Returns a range of all the social activity sets where groupId = &#63; and userId = &#63; and type = &#63;.
443            *
444            * <p>
445            * 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 SocialActivitySetModelImpl}. 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.
446            * </p>
447            *
448            * @param groupId the group ID
449            * @param userId the user ID
450            * @param type the type
451            * @param start the lower bound of the range of social activity sets
452            * @param end the upper bound of the range of social activity sets (not inclusive)
453            * @return the range of matching social activity sets
454            */
455            public static List<SocialActivitySet> findByG_U_T(long groupId,
456                    long userId, int type, int start, int end) {
457                    return getPersistence().findByG_U_T(groupId, userId, type, start, end);
458            }
459    
460            /**
461            * Returns an ordered range of all the social activity sets where groupId = &#63; and userId = &#63; and type = &#63;.
462            *
463            * <p>
464            * 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 SocialActivitySetModelImpl}. 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.
465            * </p>
466            *
467            * @param groupId the group ID
468            * @param userId the user ID
469            * @param type the type
470            * @param start the lower bound of the range of social activity sets
471            * @param end the upper bound of the range of social activity sets (not inclusive)
472            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
473            * @return the ordered range of matching social activity sets
474            */
475            public static List<SocialActivitySet> findByG_U_T(long groupId,
476                    long userId, int type, int start, int end,
477                    OrderByComparator<SocialActivitySet> orderByComparator) {
478                    return getPersistence()
479                                       .findByG_U_T(groupId, userId, type, start, end,
480                            orderByComparator);
481            }
482    
483            /**
484            * Returns an ordered range of all the social activity sets where groupId = &#63; and userId = &#63; and type = &#63;.
485            *
486            * <p>
487            * 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 SocialActivitySetModelImpl}. 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.
488            * </p>
489            *
490            * @param groupId the group ID
491            * @param userId the user ID
492            * @param type the type
493            * @param start the lower bound of the range of social activity sets
494            * @param end the upper bound of the range of social activity sets (not inclusive)
495            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
496            * @param retrieveFromCache whether to retrieve from the finder cache
497            * @return the ordered range of matching social activity sets
498            */
499            public static List<SocialActivitySet> findByG_U_T(long groupId,
500                    long userId, int type, int start, int end,
501                    OrderByComparator<SocialActivitySet> orderByComparator,
502                    boolean retrieveFromCache) {
503                    return getPersistence()
504                                       .findByG_U_T(groupId, userId, type, start, end,
505                            orderByComparator, retrieveFromCache);
506            }
507    
508            /**
509            * Returns the first social activity set in the ordered set where groupId = &#63; and userId = &#63; and type = &#63;.
510            *
511            * @param groupId the group ID
512            * @param userId the user ID
513            * @param type the type
514            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
515            * @return the first matching social activity set
516            * @throws NoSuchActivitySetException if a matching social activity set could not be found
517            */
518            public static SocialActivitySet findByG_U_T_First(long groupId,
519                    long userId, int type,
520                    OrderByComparator<SocialActivitySet> orderByComparator)
521                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
522                    return getPersistence()
523                                       .findByG_U_T_First(groupId, userId, type, orderByComparator);
524            }
525    
526            /**
527            * Returns the first social activity set in the ordered set where groupId = &#63; and userId = &#63; and type = &#63;.
528            *
529            * @param groupId the group ID
530            * @param userId the user ID
531            * @param type the type
532            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
533            * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found
534            */
535            public static SocialActivitySet fetchByG_U_T_First(long groupId,
536                    long userId, int type,
537                    OrderByComparator<SocialActivitySet> orderByComparator) {
538                    return getPersistence()
539                                       .fetchByG_U_T_First(groupId, userId, type, orderByComparator);
540            }
541    
542            /**
543            * Returns the last social activity set in the ordered set where groupId = &#63; and userId = &#63; and type = &#63;.
544            *
545            * @param groupId the group ID
546            * @param userId the user ID
547            * @param type the type
548            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
549            * @return the last matching social activity set
550            * @throws NoSuchActivitySetException if a matching social activity set could not be found
551            */
552            public static SocialActivitySet findByG_U_T_Last(long groupId, long userId,
553                    int type, OrderByComparator<SocialActivitySet> orderByComparator)
554                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
555                    return getPersistence()
556                                       .findByG_U_T_Last(groupId, userId, type, orderByComparator);
557            }
558    
559            /**
560            * Returns the last social activity set in the ordered set where groupId = &#63; and userId = &#63; and type = &#63;.
561            *
562            * @param groupId the group ID
563            * @param userId the user ID
564            * @param type the type
565            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
566            * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found
567            */
568            public static SocialActivitySet fetchByG_U_T_Last(long groupId,
569                    long userId, int type,
570                    OrderByComparator<SocialActivitySet> orderByComparator) {
571                    return getPersistence()
572                                       .fetchByG_U_T_Last(groupId, userId, type, orderByComparator);
573            }
574    
575            /**
576            * Returns the social activity sets before and after the current social activity set in the ordered set where groupId = &#63; and userId = &#63; and type = &#63;.
577            *
578            * @param activitySetId the primary key of the current social activity set
579            * @param groupId the group ID
580            * @param userId the user ID
581            * @param type the type
582            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
583            * @return the previous, current, and next social activity set
584            * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found
585            */
586            public static SocialActivitySet[] findByG_U_T_PrevAndNext(
587                    long activitySetId, long groupId, long userId, int type,
588                    OrderByComparator<SocialActivitySet> orderByComparator)
589                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
590                    return getPersistence()
591                                       .findByG_U_T_PrevAndNext(activitySetId, groupId, userId,
592                            type, orderByComparator);
593            }
594    
595            /**
596            * Removes all the social activity sets where groupId = &#63; and userId = &#63; and type = &#63; from the database.
597            *
598            * @param groupId the group ID
599            * @param userId the user ID
600            * @param type the type
601            */
602            public static void removeByG_U_T(long groupId, long userId, int type) {
603                    getPersistence().removeByG_U_T(groupId, userId, type);
604            }
605    
606            /**
607            * Returns the number of social activity sets where groupId = &#63; and userId = &#63; and type = &#63;.
608            *
609            * @param groupId the group ID
610            * @param userId the user ID
611            * @param type the type
612            * @return the number of matching social activity sets
613            */
614            public static int countByG_U_T(long groupId, long userId, int type) {
615                    return getPersistence().countByG_U_T(groupId, userId, type);
616            }
617    
618            /**
619            * Returns all the social activity sets where classNameId = &#63; and classPK = &#63; and type = &#63;.
620            *
621            * @param classNameId the class name ID
622            * @param classPK the class p k
623            * @param type the type
624            * @return the matching social activity sets
625            */
626            public static List<SocialActivitySet> findByC_C_T(long classNameId,
627                    long classPK, int type) {
628                    return getPersistence().findByC_C_T(classNameId, classPK, type);
629            }
630    
631            /**
632            * Returns a range of all the social activity sets where classNameId = &#63; and classPK = &#63; and type = &#63;.
633            *
634            * <p>
635            * 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 SocialActivitySetModelImpl}. 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.
636            * </p>
637            *
638            * @param classNameId the class name ID
639            * @param classPK the class p k
640            * @param type the type
641            * @param start the lower bound of the range of social activity sets
642            * @param end the upper bound of the range of social activity sets (not inclusive)
643            * @return the range of matching social activity sets
644            */
645            public static List<SocialActivitySet> findByC_C_T(long classNameId,
646                    long classPK, int type, int start, int end) {
647                    return getPersistence()
648                                       .findByC_C_T(classNameId, classPK, type, start, end);
649            }
650    
651            /**
652            * Returns an ordered range of all the social activity sets where classNameId = &#63; and classPK = &#63; and type = &#63;.
653            *
654            * <p>
655            * 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 SocialActivitySetModelImpl}. 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.
656            * </p>
657            *
658            * @param classNameId the class name ID
659            * @param classPK the class p k
660            * @param type the type
661            * @param start the lower bound of the range of social activity sets
662            * @param end the upper bound of the range of social activity sets (not inclusive)
663            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
664            * @return the ordered range of matching social activity sets
665            */
666            public static List<SocialActivitySet> findByC_C_T(long classNameId,
667                    long classPK, int type, int start, int end,
668                    OrderByComparator<SocialActivitySet> orderByComparator) {
669                    return getPersistence()
670                                       .findByC_C_T(classNameId, classPK, type, start, end,
671                            orderByComparator);
672            }
673    
674            /**
675            * Returns an ordered range of all the social activity sets where classNameId = &#63; and classPK = &#63; and type = &#63;.
676            *
677            * <p>
678            * 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 SocialActivitySetModelImpl}. 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.
679            * </p>
680            *
681            * @param classNameId the class name ID
682            * @param classPK the class p k
683            * @param type the type
684            * @param start the lower bound of the range of social activity sets
685            * @param end the upper bound of the range of social activity sets (not inclusive)
686            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
687            * @param retrieveFromCache whether to retrieve from the finder cache
688            * @return the ordered range of matching social activity sets
689            */
690            public static List<SocialActivitySet> findByC_C_T(long classNameId,
691                    long classPK, int type, int start, int end,
692                    OrderByComparator<SocialActivitySet> orderByComparator,
693                    boolean retrieveFromCache) {
694                    return getPersistence()
695                                       .findByC_C_T(classNameId, classPK, type, start, end,
696                            orderByComparator, retrieveFromCache);
697            }
698    
699            /**
700            * Returns the first social activity set in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
701            *
702            * @param classNameId the class name ID
703            * @param classPK the class p k
704            * @param type the type
705            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
706            * @return the first matching social activity set
707            * @throws NoSuchActivitySetException if a matching social activity set could not be found
708            */
709            public static SocialActivitySet findByC_C_T_First(long classNameId,
710                    long classPK, int type,
711                    OrderByComparator<SocialActivitySet> orderByComparator)
712                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
713                    return getPersistence()
714                                       .findByC_C_T_First(classNameId, classPK, type,
715                            orderByComparator);
716            }
717    
718            /**
719            * Returns the first social activity set in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
720            *
721            * @param classNameId the class name ID
722            * @param classPK the class p k
723            * @param type the type
724            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
725            * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found
726            */
727            public static SocialActivitySet fetchByC_C_T_First(long classNameId,
728                    long classPK, int type,
729                    OrderByComparator<SocialActivitySet> orderByComparator) {
730                    return getPersistence()
731                                       .fetchByC_C_T_First(classNameId, classPK, type,
732                            orderByComparator);
733            }
734    
735            /**
736            * Returns the last social activity set in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
737            *
738            * @param classNameId the class name ID
739            * @param classPK the class p k
740            * @param type the type
741            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
742            * @return the last matching social activity set
743            * @throws NoSuchActivitySetException if a matching social activity set could not be found
744            */
745            public static SocialActivitySet findByC_C_T_Last(long classNameId,
746                    long classPK, int type,
747                    OrderByComparator<SocialActivitySet> orderByComparator)
748                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
749                    return getPersistence()
750                                       .findByC_C_T_Last(classNameId, classPK, type,
751                            orderByComparator);
752            }
753    
754            /**
755            * Returns the last social activity set in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
756            *
757            * @param classNameId the class name ID
758            * @param classPK the class p k
759            * @param type the type
760            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
761            * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found
762            */
763            public static SocialActivitySet fetchByC_C_T_Last(long classNameId,
764                    long classPK, int type,
765                    OrderByComparator<SocialActivitySet> orderByComparator) {
766                    return getPersistence()
767                                       .fetchByC_C_T_Last(classNameId, classPK, type,
768                            orderByComparator);
769            }
770    
771            /**
772            * Returns the social activity sets before and after the current social activity set in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
773            *
774            * @param activitySetId the primary key of the current social activity set
775            * @param classNameId the class name ID
776            * @param classPK the class p k
777            * @param type the type
778            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
779            * @return the previous, current, and next social activity set
780            * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found
781            */
782            public static SocialActivitySet[] findByC_C_T_PrevAndNext(
783                    long activitySetId, long classNameId, long classPK, int type,
784                    OrderByComparator<SocialActivitySet> orderByComparator)
785                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
786                    return getPersistence()
787                                       .findByC_C_T_PrevAndNext(activitySetId, classNameId,
788                            classPK, type, orderByComparator);
789            }
790    
791            /**
792            * Removes all the social activity sets where classNameId = &#63; and classPK = &#63; and type = &#63; from the database.
793            *
794            * @param classNameId the class name ID
795            * @param classPK the class p k
796            * @param type the type
797            */
798            public static void removeByC_C_T(long classNameId, long classPK, int type) {
799                    getPersistence().removeByC_C_T(classNameId, classPK, type);
800            }
801    
802            /**
803            * Returns the number of social activity sets where classNameId = &#63; and classPK = &#63; and type = &#63;.
804            *
805            * @param classNameId the class name ID
806            * @param classPK the class p k
807            * @param type the type
808            * @return the number of matching social activity sets
809            */
810            public static int countByC_C_T(long classNameId, long classPK, int type) {
811                    return getPersistence().countByC_C_T(classNameId, classPK, type);
812            }
813    
814            /**
815            * Returns all the social activity sets where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63;.
816            *
817            * @param groupId the group ID
818            * @param userId the user ID
819            * @param classNameId the class name ID
820            * @param type the type
821            * @return the matching social activity sets
822            */
823            public static List<SocialActivitySet> findByG_U_C_T(long groupId,
824                    long userId, long classNameId, int type) {
825                    return getPersistence().findByG_U_C_T(groupId, userId, classNameId, type);
826            }
827    
828            /**
829            * Returns a range of all the social activity sets where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63;.
830            *
831            * <p>
832            * 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 SocialActivitySetModelImpl}. 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.
833            * </p>
834            *
835            * @param groupId the group ID
836            * @param userId the user ID
837            * @param classNameId the class name ID
838            * @param type the type
839            * @param start the lower bound of the range of social activity sets
840            * @param end the upper bound of the range of social activity sets (not inclusive)
841            * @return the range of matching social activity sets
842            */
843            public static List<SocialActivitySet> findByG_U_C_T(long groupId,
844                    long userId, long classNameId, int type, int start, int end) {
845                    return getPersistence()
846                                       .findByG_U_C_T(groupId, userId, classNameId, type, start, end);
847            }
848    
849            /**
850            * Returns an ordered range of all the social activity sets where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63;.
851            *
852            * <p>
853            * 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 SocialActivitySetModelImpl}. 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.
854            * </p>
855            *
856            * @param groupId the group ID
857            * @param userId the user ID
858            * @param classNameId the class name ID
859            * @param type the type
860            * @param start the lower bound of the range of social activity sets
861            * @param end the upper bound of the range of social activity sets (not inclusive)
862            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
863            * @return the ordered range of matching social activity sets
864            */
865            public static List<SocialActivitySet> findByG_U_C_T(long groupId,
866                    long userId, long classNameId, int type, int start, int end,
867                    OrderByComparator<SocialActivitySet> orderByComparator) {
868                    return getPersistence()
869                                       .findByG_U_C_T(groupId, userId, classNameId, type, start,
870                            end, orderByComparator);
871            }
872    
873            /**
874            * Returns an ordered range of all the social activity sets where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63;.
875            *
876            * <p>
877            * 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 SocialActivitySetModelImpl}. 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.
878            * </p>
879            *
880            * @param groupId the group ID
881            * @param userId the user ID
882            * @param classNameId the class name ID
883            * @param type the type
884            * @param start the lower bound of the range of social activity sets
885            * @param end the upper bound of the range of social activity sets (not inclusive)
886            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
887            * @param retrieveFromCache whether to retrieve from the finder cache
888            * @return the ordered range of matching social activity sets
889            */
890            public static List<SocialActivitySet> findByG_U_C_T(long groupId,
891                    long userId, long classNameId, int type, int start, int end,
892                    OrderByComparator<SocialActivitySet> orderByComparator,
893                    boolean retrieveFromCache) {
894                    return getPersistence()
895                                       .findByG_U_C_T(groupId, userId, classNameId, type, start,
896                            end, orderByComparator, retrieveFromCache);
897            }
898    
899            /**
900            * Returns the first social activity set in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63;.
901            *
902            * @param groupId the group ID
903            * @param userId the user ID
904            * @param classNameId the class name ID
905            * @param type the type
906            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
907            * @return the first matching social activity set
908            * @throws NoSuchActivitySetException if a matching social activity set could not be found
909            */
910            public static SocialActivitySet findByG_U_C_T_First(long groupId,
911                    long userId, long classNameId, int type,
912                    OrderByComparator<SocialActivitySet> orderByComparator)
913                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
914                    return getPersistence()
915                                       .findByG_U_C_T_First(groupId, userId, classNameId, type,
916                            orderByComparator);
917            }
918    
919            /**
920            * Returns the first social activity set in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63;.
921            *
922            * @param groupId the group ID
923            * @param userId the user ID
924            * @param classNameId the class name ID
925            * @param type the type
926            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
927            * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found
928            */
929            public static SocialActivitySet fetchByG_U_C_T_First(long groupId,
930                    long userId, long classNameId, int type,
931                    OrderByComparator<SocialActivitySet> orderByComparator) {
932                    return getPersistence()
933                                       .fetchByG_U_C_T_First(groupId, userId, classNameId, type,
934                            orderByComparator);
935            }
936    
937            /**
938            * Returns the last social activity set in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63;.
939            *
940            * @param groupId the group ID
941            * @param userId the user ID
942            * @param classNameId the class name ID
943            * @param type the type
944            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
945            * @return the last matching social activity set
946            * @throws NoSuchActivitySetException if a matching social activity set could not be found
947            */
948            public static SocialActivitySet findByG_U_C_T_Last(long groupId,
949                    long userId, long classNameId, int type,
950                    OrderByComparator<SocialActivitySet> orderByComparator)
951                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
952                    return getPersistence()
953                                       .findByG_U_C_T_Last(groupId, userId, classNameId, type,
954                            orderByComparator);
955            }
956    
957            /**
958            * Returns the last social activity set in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63;.
959            *
960            * @param groupId the group ID
961            * @param userId the user ID
962            * @param classNameId the class name ID
963            * @param type the type
964            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
965            * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found
966            */
967            public static SocialActivitySet fetchByG_U_C_T_Last(long groupId,
968                    long userId, long classNameId, int type,
969                    OrderByComparator<SocialActivitySet> orderByComparator) {
970                    return getPersistence()
971                                       .fetchByG_U_C_T_Last(groupId, userId, classNameId, type,
972                            orderByComparator);
973            }
974    
975            /**
976            * Returns the social activity sets before and after the current social activity set in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63;.
977            *
978            * @param activitySetId the primary key of the current social activity set
979            * @param groupId the group ID
980            * @param userId the user ID
981            * @param classNameId the class name ID
982            * @param type the type
983            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
984            * @return the previous, current, and next social activity set
985            * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found
986            */
987            public static SocialActivitySet[] findByG_U_C_T_PrevAndNext(
988                    long activitySetId, long groupId, long userId, long classNameId,
989                    int type, OrderByComparator<SocialActivitySet> orderByComparator)
990                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
991                    return getPersistence()
992                                       .findByG_U_C_T_PrevAndNext(activitySetId, groupId, userId,
993                            classNameId, type, orderByComparator);
994            }
995    
996            /**
997            * Removes all the social activity sets where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63; from the database.
998            *
999            * @param groupId the group ID
1000            * @param userId the user ID
1001            * @param classNameId the class name ID
1002            * @param type the type
1003            */
1004            public static void removeByG_U_C_T(long groupId, long userId,
1005                    long classNameId, int type) {
1006                    getPersistence().removeByG_U_C_T(groupId, userId, classNameId, type);
1007            }
1008    
1009            /**
1010            * Returns the number of social activity sets where groupId = &#63; and userId = &#63; and classNameId = &#63; and type = &#63;.
1011            *
1012            * @param groupId the group ID
1013            * @param userId the user ID
1014            * @param classNameId the class name ID
1015            * @param type the type
1016            * @return the number of matching social activity sets
1017            */
1018            public static int countByG_U_C_T(long groupId, long userId,
1019                    long classNameId, int type) {
1020                    return getPersistence()
1021                                       .countByG_U_C_T(groupId, userId, classNameId, type);
1022            }
1023    
1024            /**
1025            * Returns all the social activity sets where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
1026            *
1027            * @param userId the user ID
1028            * @param classNameId the class name ID
1029            * @param classPK the class p k
1030            * @param type the type
1031            * @return the matching social activity sets
1032            */
1033            public static List<SocialActivitySet> findByU_C_C_T(long userId,
1034                    long classNameId, long classPK, int type) {
1035                    return getPersistence().findByU_C_C_T(userId, classNameId, classPK, type);
1036            }
1037    
1038            /**
1039            * Returns a range of all the social activity sets where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
1040            *
1041            * <p>
1042            * 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 SocialActivitySetModelImpl}. 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.
1043            * </p>
1044            *
1045            * @param userId the user ID
1046            * @param classNameId the class name ID
1047            * @param classPK the class p k
1048            * @param type the type
1049            * @param start the lower bound of the range of social activity sets
1050            * @param end the upper bound of the range of social activity sets (not inclusive)
1051            * @return the range of matching social activity sets
1052            */
1053            public static List<SocialActivitySet> findByU_C_C_T(long userId,
1054                    long classNameId, long classPK, int type, int start, int end) {
1055                    return getPersistence()
1056                                       .findByU_C_C_T(userId, classNameId, classPK, type, start, end);
1057            }
1058    
1059            /**
1060            * Returns an ordered range of all the social activity sets where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
1061            *
1062            * <p>
1063            * 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 SocialActivitySetModelImpl}. 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.
1064            * </p>
1065            *
1066            * @param userId the user ID
1067            * @param classNameId the class name ID
1068            * @param classPK the class p k
1069            * @param type the type
1070            * @param start the lower bound of the range of social activity sets
1071            * @param end the upper bound of the range of social activity sets (not inclusive)
1072            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1073            * @return the ordered range of matching social activity sets
1074            */
1075            public static List<SocialActivitySet> findByU_C_C_T(long userId,
1076                    long classNameId, long classPK, int type, int start, int end,
1077                    OrderByComparator<SocialActivitySet> orderByComparator) {
1078                    return getPersistence()
1079                                       .findByU_C_C_T(userId, classNameId, classPK, type, start,
1080                            end, orderByComparator);
1081            }
1082    
1083            /**
1084            * Returns an ordered range of all the social activity sets where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
1085            *
1086            * <p>
1087            * 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 SocialActivitySetModelImpl}. 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.
1088            * </p>
1089            *
1090            * @param userId the user ID
1091            * @param classNameId the class name ID
1092            * @param classPK the class p k
1093            * @param type the type
1094            * @param start the lower bound of the range of social activity sets
1095            * @param end the upper bound of the range of social activity sets (not inclusive)
1096            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1097            * @param retrieveFromCache whether to retrieve from the finder cache
1098            * @return the ordered range of matching social activity sets
1099            */
1100            public static List<SocialActivitySet> findByU_C_C_T(long userId,
1101                    long classNameId, long classPK, int type, int start, int end,
1102                    OrderByComparator<SocialActivitySet> orderByComparator,
1103                    boolean retrieveFromCache) {
1104                    return getPersistence()
1105                                       .findByU_C_C_T(userId, classNameId, classPK, type, start,
1106                            end, orderByComparator, retrieveFromCache);
1107            }
1108    
1109            /**
1110            * Returns the first social activity set in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
1111            *
1112            * @param userId the user ID
1113            * @param classNameId the class name ID
1114            * @param classPK the class p k
1115            * @param type the type
1116            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1117            * @return the first matching social activity set
1118            * @throws NoSuchActivitySetException if a matching social activity set could not be found
1119            */
1120            public static SocialActivitySet findByU_C_C_T_First(long userId,
1121                    long classNameId, long classPK, int type,
1122                    OrderByComparator<SocialActivitySet> orderByComparator)
1123                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
1124                    return getPersistence()
1125                                       .findByU_C_C_T_First(userId, classNameId, classPK, type,
1126                            orderByComparator);
1127            }
1128    
1129            /**
1130            * Returns the first social activity set in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
1131            *
1132            * @param userId the user ID
1133            * @param classNameId the class name ID
1134            * @param classPK the class p k
1135            * @param type the type
1136            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1137            * @return the first matching social activity set, or <code>null</code> if a matching social activity set could not be found
1138            */
1139            public static SocialActivitySet fetchByU_C_C_T_First(long userId,
1140                    long classNameId, long classPK, int type,
1141                    OrderByComparator<SocialActivitySet> orderByComparator) {
1142                    return getPersistence()
1143                                       .fetchByU_C_C_T_First(userId, classNameId, classPK, type,
1144                            orderByComparator);
1145            }
1146    
1147            /**
1148            * Returns the last social activity set in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
1149            *
1150            * @param userId the user ID
1151            * @param classNameId the class name ID
1152            * @param classPK the class p k
1153            * @param type the type
1154            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1155            * @return the last matching social activity set
1156            * @throws NoSuchActivitySetException if a matching social activity set could not be found
1157            */
1158            public static SocialActivitySet findByU_C_C_T_Last(long userId,
1159                    long classNameId, long classPK, int type,
1160                    OrderByComparator<SocialActivitySet> orderByComparator)
1161                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
1162                    return getPersistence()
1163                                       .findByU_C_C_T_Last(userId, classNameId, classPK, type,
1164                            orderByComparator);
1165            }
1166    
1167            /**
1168            * Returns the last social activity set in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
1169            *
1170            * @param userId the user ID
1171            * @param classNameId the class name ID
1172            * @param classPK the class p k
1173            * @param type the type
1174            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1175            * @return the last matching social activity set, or <code>null</code> if a matching social activity set could not be found
1176            */
1177            public static SocialActivitySet fetchByU_C_C_T_Last(long userId,
1178                    long classNameId, long classPK, int type,
1179                    OrderByComparator<SocialActivitySet> orderByComparator) {
1180                    return getPersistence()
1181                                       .fetchByU_C_C_T_Last(userId, classNameId, classPK, type,
1182                            orderByComparator);
1183            }
1184    
1185            /**
1186            * Returns the social activity sets before and after the current social activity set in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
1187            *
1188            * @param activitySetId the primary key of the current social activity set
1189            * @param userId the user ID
1190            * @param classNameId the class name ID
1191            * @param classPK the class p k
1192            * @param type the type
1193            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1194            * @return the previous, current, and next social activity set
1195            * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found
1196            */
1197            public static SocialActivitySet[] findByU_C_C_T_PrevAndNext(
1198                    long activitySetId, long userId, long classNameId, long classPK,
1199                    int type, OrderByComparator<SocialActivitySet> orderByComparator)
1200                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
1201                    return getPersistence()
1202                                       .findByU_C_C_T_PrevAndNext(activitySetId, userId,
1203                            classNameId, classPK, type, orderByComparator);
1204            }
1205    
1206            /**
1207            * Removes all the social activity sets where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; from the database.
1208            *
1209            * @param userId the user ID
1210            * @param classNameId the class name ID
1211            * @param classPK the class p k
1212            * @param type the type
1213            */
1214            public static void removeByU_C_C_T(long userId, long classNameId,
1215                    long classPK, int type) {
1216                    getPersistence().removeByU_C_C_T(userId, classNameId, classPK, type);
1217            }
1218    
1219            /**
1220            * Returns the number of social activity sets where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63;.
1221            *
1222            * @param userId the user ID
1223            * @param classNameId the class name ID
1224            * @param classPK the class p k
1225            * @param type the type
1226            * @return the number of matching social activity sets
1227            */
1228            public static int countByU_C_C_T(long userId, long classNameId,
1229                    long classPK, int type) {
1230                    return getPersistence()
1231                                       .countByU_C_C_T(userId, classNameId, classPK, type);
1232            }
1233    
1234            /**
1235            * Caches the social activity set in the entity cache if it is enabled.
1236            *
1237            * @param socialActivitySet the social activity set
1238            */
1239            public static void cacheResult(SocialActivitySet socialActivitySet) {
1240                    getPersistence().cacheResult(socialActivitySet);
1241            }
1242    
1243            /**
1244            * Caches the social activity sets in the entity cache if it is enabled.
1245            *
1246            * @param socialActivitySets the social activity sets
1247            */
1248            public static void cacheResult(List<SocialActivitySet> socialActivitySets) {
1249                    getPersistence().cacheResult(socialActivitySets);
1250            }
1251    
1252            /**
1253            * Creates a new social activity set with the primary key. Does not add the social activity set to the database.
1254            *
1255            * @param activitySetId the primary key for the new social activity set
1256            * @return the new social activity set
1257            */
1258            public static SocialActivitySet create(long activitySetId) {
1259                    return getPersistence().create(activitySetId);
1260            }
1261    
1262            /**
1263            * Removes the social activity set with the primary key from the database. Also notifies the appropriate model listeners.
1264            *
1265            * @param activitySetId the primary key of the social activity set
1266            * @return the social activity set that was removed
1267            * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found
1268            */
1269            public static SocialActivitySet remove(long activitySetId)
1270                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
1271                    return getPersistence().remove(activitySetId);
1272            }
1273    
1274            public static SocialActivitySet updateImpl(
1275                    SocialActivitySet socialActivitySet) {
1276                    return getPersistence().updateImpl(socialActivitySet);
1277            }
1278    
1279            /**
1280            * Returns the social activity set with the primary key or throws a {@link NoSuchActivitySetException} if it could not be found.
1281            *
1282            * @param activitySetId the primary key of the social activity set
1283            * @return the social activity set
1284            * @throws NoSuchActivitySetException if a social activity set with the primary key could not be found
1285            */
1286            public static SocialActivitySet findByPrimaryKey(long activitySetId)
1287                    throws com.liferay.portlet.social.exception.NoSuchActivitySetException {
1288                    return getPersistence().findByPrimaryKey(activitySetId);
1289            }
1290    
1291            /**
1292            * Returns the social activity set with the primary key or returns <code>null</code> if it could not be found.
1293            *
1294            * @param activitySetId the primary key of the social activity set
1295            * @return the social activity set, or <code>null</code> if a social activity set with the primary key could not be found
1296            */
1297            public static SocialActivitySet fetchByPrimaryKey(long activitySetId) {
1298                    return getPersistence().fetchByPrimaryKey(activitySetId);
1299            }
1300    
1301            public static java.util.Map<java.io.Serializable, SocialActivitySet> fetchByPrimaryKeys(
1302                    java.util.Set<java.io.Serializable> primaryKeys) {
1303                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1304            }
1305    
1306            /**
1307            * Returns all the social activity sets.
1308            *
1309            * @return the social activity sets
1310            */
1311            public static List<SocialActivitySet> findAll() {
1312                    return getPersistence().findAll();
1313            }
1314    
1315            /**
1316            * Returns a range of all the social activity sets.
1317            *
1318            * <p>
1319            * 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 SocialActivitySetModelImpl}. 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.
1320            * </p>
1321            *
1322            * @param start the lower bound of the range of social activity sets
1323            * @param end the upper bound of the range of social activity sets (not inclusive)
1324            * @return the range of social activity sets
1325            */
1326            public static List<SocialActivitySet> findAll(int start, int end) {
1327                    return getPersistence().findAll(start, end);
1328            }
1329    
1330            /**
1331            * Returns an ordered range of all the social activity sets.
1332            *
1333            * <p>
1334            * 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 SocialActivitySetModelImpl}. 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.
1335            * </p>
1336            *
1337            * @param start the lower bound of the range of social activity sets
1338            * @param end the upper bound of the range of social activity sets (not inclusive)
1339            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1340            * @return the ordered range of social activity sets
1341            */
1342            public static List<SocialActivitySet> findAll(int start, int end,
1343                    OrderByComparator<SocialActivitySet> orderByComparator) {
1344                    return getPersistence().findAll(start, end, orderByComparator);
1345            }
1346    
1347            /**
1348            * Returns an ordered range of all the social activity sets.
1349            *
1350            * <p>
1351            * 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 SocialActivitySetModelImpl}. 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.
1352            * </p>
1353            *
1354            * @param start the lower bound of the range of social activity sets
1355            * @param end the upper bound of the range of social activity sets (not inclusive)
1356            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1357            * @param retrieveFromCache whether to retrieve from the finder cache
1358            * @return the ordered range of social activity sets
1359            */
1360            public static List<SocialActivitySet> findAll(int start, int end,
1361                    OrderByComparator<SocialActivitySet> orderByComparator,
1362                    boolean retrieveFromCache) {
1363                    return getPersistence()
1364                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1365            }
1366    
1367            /**
1368            * Removes all the social activity sets from the database.
1369            */
1370            public static void removeAll() {
1371                    getPersistence().removeAll();
1372            }
1373    
1374            /**
1375            * Returns the number of social activity sets.
1376            *
1377            * @return the number of social activity sets
1378            */
1379            public static int countAll() {
1380                    return getPersistence().countAll();
1381            }
1382    
1383            public static java.util.Set<java.lang.String> getBadColumnNames() {
1384                    return getPersistence().getBadColumnNames();
1385            }
1386    
1387            public static SocialActivitySetPersistence getPersistence() {
1388                    if (_persistence == null) {
1389                            _persistence = (SocialActivitySetPersistence)PortalBeanLocatorUtil.locate(SocialActivitySetPersistence.class.getName());
1390    
1391                            ReferenceRegistry.registerReference(SocialActivitySetUtil.class,
1392                                    "_persistence");
1393                    }
1394    
1395                    return _persistence;
1396            }
1397    
1398            private static SocialActivitySetPersistence _persistence;
1399    }