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.SocialActivity;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the social activity service. This utility wraps {@link com.liferay.portlet.social.service.persistence.impl.SocialActivityPersistenceImpl} 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 SocialActivityPersistence
038     * @see com.liferay.portlet.social.service.persistence.impl.SocialActivityPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class SocialActivityUtil {
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(SocialActivity socialActivity) {
060                    getPersistence().clearCache(socialActivity);
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<SocialActivity> 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<SocialActivity> 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<SocialActivity> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<SocialActivity> 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 SocialActivity update(SocialActivity socialActivity) {
101                    return getPersistence().update(socialActivity);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static SocialActivity update(SocialActivity socialActivity,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(socialActivity, serviceContext);
110            }
111    
112            /**
113            * Returns all the social activities where groupId = &#63;.
114            *
115            * @param groupId the group ID
116            * @return the matching social activities
117            */
118            public static List<SocialActivity> findByGroupId(long groupId) {
119                    return getPersistence().findByGroupId(groupId);
120            }
121    
122            /**
123            * Returns a range of all the social activities 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 SocialActivityModelImpl}. 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 activities
131            * @param end the upper bound of the range of social activities (not inclusive)
132            * @return the range of matching social activities
133            */
134            public static List<SocialActivity> findByGroupId(long groupId, int start,
135                    int end) {
136                    return getPersistence().findByGroupId(groupId, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the social activities 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 SocialActivityModelImpl}. 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 activities
148            * @param end the upper bound of the range of social activities (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching social activities
151            */
152            public static List<SocialActivity> findByGroupId(long groupId, int start,
153                    int end, OrderByComparator<SocialActivity> orderByComparator) {
154                    return getPersistence()
155                                       .findByGroupId(groupId, start, end, orderByComparator);
156            }
157    
158            /**
159            * Returns the first social activity in the ordered set where groupId = &#63;.
160            *
161            * @param groupId the group ID
162            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
163            * @return the first matching social activity
164            * @throws NoSuchActivityException if a matching social activity could not be found
165            */
166            public static SocialActivity findByGroupId_First(long groupId,
167                    OrderByComparator<SocialActivity> orderByComparator)
168                    throws com.liferay.portlet.social.NoSuchActivityException {
169                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
170            }
171    
172            /**
173            * Returns the first social activity in the ordered set where groupId = &#63;.
174            *
175            * @param groupId the group ID
176            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
177            * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found
178            */
179            public static SocialActivity fetchByGroupId_First(long groupId,
180                    OrderByComparator<SocialActivity> orderByComparator) {
181                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
182            }
183    
184            /**
185            * Returns the last social activity in the ordered set where groupId = &#63;.
186            *
187            * @param groupId the group ID
188            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
189            * @return the last matching social activity
190            * @throws NoSuchActivityException if a matching social activity could not be found
191            */
192            public static SocialActivity findByGroupId_Last(long groupId,
193                    OrderByComparator<SocialActivity> orderByComparator)
194                    throws com.liferay.portlet.social.NoSuchActivityException {
195                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
196            }
197    
198            /**
199            * Returns the last social activity in the ordered set where groupId = &#63;.
200            *
201            * @param groupId the group ID
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found
204            */
205            public static SocialActivity fetchByGroupId_Last(long groupId,
206                    OrderByComparator<SocialActivity> orderByComparator) {
207                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
208            }
209    
210            /**
211            * Returns the social activities before and after the current social activity in the ordered set where groupId = &#63;.
212            *
213            * @param activityId the primary key of the current social activity
214            * @param groupId the group ID
215            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
216            * @return the previous, current, and next social activity
217            * @throws NoSuchActivityException if a social activity with the primary key could not be found
218            */
219            public static SocialActivity[] findByGroupId_PrevAndNext(long activityId,
220                    long groupId, OrderByComparator<SocialActivity> orderByComparator)
221                    throws com.liferay.portlet.social.NoSuchActivityException {
222                    return getPersistence()
223                                       .findByGroupId_PrevAndNext(activityId, groupId,
224                            orderByComparator);
225            }
226    
227            /**
228            * Removes all the social activities where groupId = &#63; from the database.
229            *
230            * @param groupId the group ID
231            */
232            public static void removeByGroupId(long groupId) {
233                    getPersistence().removeByGroupId(groupId);
234            }
235    
236            /**
237            * Returns the number of social activities where groupId = &#63;.
238            *
239            * @param groupId the group ID
240            * @return the number of matching social activities
241            */
242            public static int countByGroupId(long groupId) {
243                    return getPersistence().countByGroupId(groupId);
244            }
245    
246            /**
247            * Returns all the social activities where companyId = &#63;.
248            *
249            * @param companyId the company ID
250            * @return the matching social activities
251            */
252            public static List<SocialActivity> findByCompanyId(long companyId) {
253                    return getPersistence().findByCompanyId(companyId);
254            }
255    
256            /**
257            * Returns a range of all the social activities where companyId = &#63;.
258            *
259            * <p>
260            * 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 SocialActivityModelImpl}. 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.
261            * </p>
262            *
263            * @param companyId the company ID
264            * @param start the lower bound of the range of social activities
265            * @param end the upper bound of the range of social activities (not inclusive)
266            * @return the range of matching social activities
267            */
268            public static List<SocialActivity> findByCompanyId(long companyId,
269                    int start, int end) {
270                    return getPersistence().findByCompanyId(companyId, start, end);
271            }
272    
273            /**
274            * Returns an ordered range of all the social activities where companyId = &#63;.
275            *
276            * <p>
277            * 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 SocialActivityModelImpl}. 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.
278            * </p>
279            *
280            * @param companyId the company ID
281            * @param start the lower bound of the range of social activities
282            * @param end the upper bound of the range of social activities (not inclusive)
283            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
284            * @return the ordered range of matching social activities
285            */
286            public static List<SocialActivity> findByCompanyId(long companyId,
287                    int start, int end, OrderByComparator<SocialActivity> orderByComparator) {
288                    return getPersistence()
289                                       .findByCompanyId(companyId, start, end, orderByComparator);
290            }
291    
292            /**
293            * Returns the first social activity in the ordered set where companyId = &#63;.
294            *
295            * @param companyId the company ID
296            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
297            * @return the first matching social activity
298            * @throws NoSuchActivityException if a matching social activity could not be found
299            */
300            public static SocialActivity findByCompanyId_First(long companyId,
301                    OrderByComparator<SocialActivity> orderByComparator)
302                    throws com.liferay.portlet.social.NoSuchActivityException {
303                    return getPersistence()
304                                       .findByCompanyId_First(companyId, orderByComparator);
305            }
306    
307            /**
308            * Returns the first social activity in the ordered set where companyId = &#63;.
309            *
310            * @param companyId the company ID
311            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
312            * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found
313            */
314            public static SocialActivity fetchByCompanyId_First(long companyId,
315                    OrderByComparator<SocialActivity> orderByComparator) {
316                    return getPersistence()
317                                       .fetchByCompanyId_First(companyId, orderByComparator);
318            }
319    
320            /**
321            * Returns the last social activity in the ordered set where companyId = &#63;.
322            *
323            * @param companyId the company ID
324            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
325            * @return the last matching social activity
326            * @throws NoSuchActivityException if a matching social activity could not be found
327            */
328            public static SocialActivity findByCompanyId_Last(long companyId,
329                    OrderByComparator<SocialActivity> orderByComparator)
330                    throws com.liferay.portlet.social.NoSuchActivityException {
331                    return getPersistence()
332                                       .findByCompanyId_Last(companyId, orderByComparator);
333            }
334    
335            /**
336            * Returns the last social activity in the ordered set where companyId = &#63;.
337            *
338            * @param companyId the company ID
339            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
340            * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found
341            */
342            public static SocialActivity fetchByCompanyId_Last(long companyId,
343                    OrderByComparator<SocialActivity> orderByComparator) {
344                    return getPersistence()
345                                       .fetchByCompanyId_Last(companyId, orderByComparator);
346            }
347    
348            /**
349            * Returns the social activities before and after the current social activity in the ordered set where companyId = &#63;.
350            *
351            * @param activityId the primary key of the current social activity
352            * @param companyId the company ID
353            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
354            * @return the previous, current, and next social activity
355            * @throws NoSuchActivityException if a social activity with the primary key could not be found
356            */
357            public static SocialActivity[] findByCompanyId_PrevAndNext(
358                    long activityId, long companyId,
359                    OrderByComparator<SocialActivity> orderByComparator)
360                    throws com.liferay.portlet.social.NoSuchActivityException {
361                    return getPersistence()
362                                       .findByCompanyId_PrevAndNext(activityId, companyId,
363                            orderByComparator);
364            }
365    
366            /**
367            * Removes all the social activities where companyId = &#63; from the database.
368            *
369            * @param companyId the company ID
370            */
371            public static void removeByCompanyId(long companyId) {
372                    getPersistence().removeByCompanyId(companyId);
373            }
374    
375            /**
376            * Returns the number of social activities where companyId = &#63;.
377            *
378            * @param companyId the company ID
379            * @return the number of matching social activities
380            */
381            public static int countByCompanyId(long companyId) {
382                    return getPersistence().countByCompanyId(companyId);
383            }
384    
385            /**
386            * Returns all the social activities where userId = &#63;.
387            *
388            * @param userId the user ID
389            * @return the matching social activities
390            */
391            public static List<SocialActivity> findByUserId(long userId) {
392                    return getPersistence().findByUserId(userId);
393            }
394    
395            /**
396            * Returns a range of all the social activities where userId = &#63;.
397            *
398            * <p>
399            * 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 SocialActivityModelImpl}. 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.
400            * </p>
401            *
402            * @param userId the user ID
403            * @param start the lower bound of the range of social activities
404            * @param end the upper bound of the range of social activities (not inclusive)
405            * @return the range of matching social activities
406            */
407            public static List<SocialActivity> findByUserId(long userId, int start,
408                    int end) {
409                    return getPersistence().findByUserId(userId, start, end);
410            }
411    
412            /**
413            * Returns an ordered range of all the social activities where userId = &#63;.
414            *
415            * <p>
416            * 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 SocialActivityModelImpl}. 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.
417            * </p>
418            *
419            * @param userId the user ID
420            * @param start the lower bound of the range of social activities
421            * @param end the upper bound of the range of social activities (not inclusive)
422            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
423            * @return the ordered range of matching social activities
424            */
425            public static List<SocialActivity> findByUserId(long userId, int start,
426                    int end, OrderByComparator<SocialActivity> orderByComparator) {
427                    return getPersistence()
428                                       .findByUserId(userId, start, end, orderByComparator);
429            }
430    
431            /**
432            * Returns the first social activity in the ordered set where userId = &#63;.
433            *
434            * @param userId the user ID
435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
436            * @return the first matching social activity
437            * @throws NoSuchActivityException if a matching social activity could not be found
438            */
439            public static SocialActivity findByUserId_First(long userId,
440                    OrderByComparator<SocialActivity> orderByComparator)
441                    throws com.liferay.portlet.social.NoSuchActivityException {
442                    return getPersistence().findByUserId_First(userId, orderByComparator);
443            }
444    
445            /**
446            * Returns the first social activity in the ordered set where userId = &#63;.
447            *
448            * @param userId the user ID
449            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
450            * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found
451            */
452            public static SocialActivity fetchByUserId_First(long userId,
453                    OrderByComparator<SocialActivity> orderByComparator) {
454                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
455            }
456    
457            /**
458            * Returns the last social activity in the ordered set where userId = &#63;.
459            *
460            * @param userId the user ID
461            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
462            * @return the last matching social activity
463            * @throws NoSuchActivityException if a matching social activity could not be found
464            */
465            public static SocialActivity findByUserId_Last(long userId,
466                    OrderByComparator<SocialActivity> orderByComparator)
467                    throws com.liferay.portlet.social.NoSuchActivityException {
468                    return getPersistence().findByUserId_Last(userId, orderByComparator);
469            }
470    
471            /**
472            * Returns the last social activity in the ordered set where userId = &#63;.
473            *
474            * @param userId the user ID
475            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
476            * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found
477            */
478            public static SocialActivity fetchByUserId_Last(long userId,
479                    OrderByComparator<SocialActivity> orderByComparator) {
480                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
481            }
482    
483            /**
484            * Returns the social activities before and after the current social activity in the ordered set where userId = &#63;.
485            *
486            * @param activityId the primary key of the current social activity
487            * @param userId the user ID
488            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
489            * @return the previous, current, and next social activity
490            * @throws NoSuchActivityException if a social activity with the primary key could not be found
491            */
492            public static SocialActivity[] findByUserId_PrevAndNext(long activityId,
493                    long userId, OrderByComparator<SocialActivity> orderByComparator)
494                    throws com.liferay.portlet.social.NoSuchActivityException {
495                    return getPersistence()
496                                       .findByUserId_PrevAndNext(activityId, userId,
497                            orderByComparator);
498            }
499    
500            /**
501            * Removes all the social activities where userId = &#63; from the database.
502            *
503            * @param userId the user ID
504            */
505            public static void removeByUserId(long userId) {
506                    getPersistence().removeByUserId(userId);
507            }
508    
509            /**
510            * Returns the number of social activities where userId = &#63;.
511            *
512            * @param userId the user ID
513            * @return the number of matching social activities
514            */
515            public static int countByUserId(long userId) {
516                    return getPersistence().countByUserId(userId);
517            }
518    
519            /**
520            * Returns all the social activities where activitySetId = &#63;.
521            *
522            * @param activitySetId the activity set ID
523            * @return the matching social activities
524            */
525            public static List<SocialActivity> findByActivitySetId(long activitySetId) {
526                    return getPersistence().findByActivitySetId(activitySetId);
527            }
528    
529            /**
530            * Returns a range of all the social activities where activitySetId = &#63;.
531            *
532            * <p>
533            * 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 SocialActivityModelImpl}. 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.
534            * </p>
535            *
536            * @param activitySetId the activity set ID
537            * @param start the lower bound of the range of social activities
538            * @param end the upper bound of the range of social activities (not inclusive)
539            * @return the range of matching social activities
540            */
541            public static List<SocialActivity> findByActivitySetId(long activitySetId,
542                    int start, int end) {
543                    return getPersistence().findByActivitySetId(activitySetId, start, end);
544            }
545    
546            /**
547            * Returns an ordered range of all the social activities where activitySetId = &#63;.
548            *
549            * <p>
550            * 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 SocialActivityModelImpl}. 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.
551            * </p>
552            *
553            * @param activitySetId the activity set ID
554            * @param start the lower bound of the range of social activities
555            * @param end the upper bound of the range of social activities (not inclusive)
556            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
557            * @return the ordered range of matching social activities
558            */
559            public static List<SocialActivity> findByActivitySetId(long activitySetId,
560                    int start, int end, OrderByComparator<SocialActivity> orderByComparator) {
561                    return getPersistence()
562                                       .findByActivitySetId(activitySetId, start, end,
563                            orderByComparator);
564            }
565    
566            /**
567            * Returns the first social activity in the ordered set where activitySetId = &#63;.
568            *
569            * @param activitySetId the activity set ID
570            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
571            * @return the first matching social activity
572            * @throws NoSuchActivityException if a matching social activity could not be found
573            */
574            public static SocialActivity findByActivitySetId_First(long activitySetId,
575                    OrderByComparator<SocialActivity> orderByComparator)
576                    throws com.liferay.portlet.social.NoSuchActivityException {
577                    return getPersistence()
578                                       .findByActivitySetId_First(activitySetId, orderByComparator);
579            }
580    
581            /**
582            * Returns the first social activity in the ordered set where activitySetId = &#63;.
583            *
584            * @param activitySetId the activity set ID
585            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
586            * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found
587            */
588            public static SocialActivity fetchByActivitySetId_First(
589                    long activitySetId, OrderByComparator<SocialActivity> orderByComparator) {
590                    return getPersistence()
591                                       .fetchByActivitySetId_First(activitySetId, orderByComparator);
592            }
593    
594            /**
595            * Returns the last social activity in the ordered set where activitySetId = &#63;.
596            *
597            * @param activitySetId the activity set ID
598            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
599            * @return the last matching social activity
600            * @throws NoSuchActivityException if a matching social activity could not be found
601            */
602            public static SocialActivity findByActivitySetId_Last(long activitySetId,
603                    OrderByComparator<SocialActivity> orderByComparator)
604                    throws com.liferay.portlet.social.NoSuchActivityException {
605                    return getPersistence()
606                                       .findByActivitySetId_Last(activitySetId, orderByComparator);
607            }
608    
609            /**
610            * Returns the last social activity in the ordered set where activitySetId = &#63;.
611            *
612            * @param activitySetId the activity set ID
613            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
614            * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found
615            */
616            public static SocialActivity fetchByActivitySetId_Last(long activitySetId,
617                    OrderByComparator<SocialActivity> orderByComparator) {
618                    return getPersistence()
619                                       .fetchByActivitySetId_Last(activitySetId, orderByComparator);
620            }
621    
622            /**
623            * Returns the social activities before and after the current social activity in the ordered set where activitySetId = &#63;.
624            *
625            * @param activityId the primary key of the current social activity
626            * @param activitySetId the activity set ID
627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
628            * @return the previous, current, and next social activity
629            * @throws NoSuchActivityException if a social activity with the primary key could not be found
630            */
631            public static SocialActivity[] findByActivitySetId_PrevAndNext(
632                    long activityId, long activitySetId,
633                    OrderByComparator<SocialActivity> orderByComparator)
634                    throws com.liferay.portlet.social.NoSuchActivityException {
635                    return getPersistence()
636                                       .findByActivitySetId_PrevAndNext(activityId, activitySetId,
637                            orderByComparator);
638            }
639    
640            /**
641            * Removes all the social activities where activitySetId = &#63; from the database.
642            *
643            * @param activitySetId the activity set ID
644            */
645            public static void removeByActivitySetId(long activitySetId) {
646                    getPersistence().removeByActivitySetId(activitySetId);
647            }
648    
649            /**
650            * Returns the number of social activities where activitySetId = &#63;.
651            *
652            * @param activitySetId the activity set ID
653            * @return the number of matching social activities
654            */
655            public static int countByActivitySetId(long activitySetId) {
656                    return getPersistence().countByActivitySetId(activitySetId);
657            }
658    
659            /**
660            * Returns the social activity where mirrorActivityId = &#63; or throws a {@link NoSuchActivityException} if it could not be found.
661            *
662            * @param mirrorActivityId the mirror activity ID
663            * @return the matching social activity
664            * @throws NoSuchActivityException if a matching social activity could not be found
665            */
666            public static SocialActivity findByMirrorActivityId(long mirrorActivityId)
667                    throws com.liferay.portlet.social.NoSuchActivityException {
668                    return getPersistence().findByMirrorActivityId(mirrorActivityId);
669            }
670    
671            /**
672            * Returns the social activity where mirrorActivityId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
673            *
674            * @param mirrorActivityId the mirror activity ID
675            * @return the matching social activity, or <code>null</code> if a matching social activity could not be found
676            */
677            public static SocialActivity fetchByMirrorActivityId(long mirrorActivityId) {
678                    return getPersistence().fetchByMirrorActivityId(mirrorActivityId);
679            }
680    
681            /**
682            * Returns the social activity where mirrorActivityId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
683            *
684            * @param mirrorActivityId the mirror activity ID
685            * @param retrieveFromCache whether to use the finder cache
686            * @return the matching social activity, or <code>null</code> if a matching social activity could not be found
687            */
688            public static SocialActivity fetchByMirrorActivityId(
689                    long mirrorActivityId, boolean retrieveFromCache) {
690                    return getPersistence()
691                                       .fetchByMirrorActivityId(mirrorActivityId, retrieveFromCache);
692            }
693    
694            /**
695            * Removes the social activity where mirrorActivityId = &#63; from the database.
696            *
697            * @param mirrorActivityId the mirror activity ID
698            * @return the social activity that was removed
699            */
700            public static SocialActivity removeByMirrorActivityId(long mirrorActivityId)
701                    throws com.liferay.portlet.social.NoSuchActivityException {
702                    return getPersistence().removeByMirrorActivityId(mirrorActivityId);
703            }
704    
705            /**
706            * Returns the number of social activities where mirrorActivityId = &#63;.
707            *
708            * @param mirrorActivityId the mirror activity ID
709            * @return the number of matching social activities
710            */
711            public static int countByMirrorActivityId(long mirrorActivityId) {
712                    return getPersistence().countByMirrorActivityId(mirrorActivityId);
713            }
714    
715            /**
716            * Returns all the social activities where classNameId = &#63;.
717            *
718            * @param classNameId the class name ID
719            * @return the matching social activities
720            */
721            public static List<SocialActivity> findByClassNameId(long classNameId) {
722                    return getPersistence().findByClassNameId(classNameId);
723            }
724    
725            /**
726            * Returns a range of all the social activities where classNameId = &#63;.
727            *
728            * <p>
729            * 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 SocialActivityModelImpl}. 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.
730            * </p>
731            *
732            * @param classNameId the class name ID
733            * @param start the lower bound of the range of social activities
734            * @param end the upper bound of the range of social activities (not inclusive)
735            * @return the range of matching social activities
736            */
737            public static List<SocialActivity> findByClassNameId(long classNameId,
738                    int start, int end) {
739                    return getPersistence().findByClassNameId(classNameId, start, end);
740            }
741    
742            /**
743            * Returns an ordered range of all the social activities where classNameId = &#63;.
744            *
745            * <p>
746            * 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 SocialActivityModelImpl}. 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.
747            * </p>
748            *
749            * @param classNameId the class name ID
750            * @param start the lower bound of the range of social activities
751            * @param end the upper bound of the range of social activities (not inclusive)
752            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
753            * @return the ordered range of matching social activities
754            */
755            public static List<SocialActivity> findByClassNameId(long classNameId,
756                    int start, int end, OrderByComparator<SocialActivity> orderByComparator) {
757                    return getPersistence()
758                                       .findByClassNameId(classNameId, start, end, orderByComparator);
759            }
760    
761            /**
762            * Returns the first social activity in the ordered set where classNameId = &#63;.
763            *
764            * @param classNameId the class name ID
765            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
766            * @return the first matching social activity
767            * @throws NoSuchActivityException if a matching social activity could not be found
768            */
769            public static SocialActivity findByClassNameId_First(long classNameId,
770                    OrderByComparator<SocialActivity> orderByComparator)
771                    throws com.liferay.portlet.social.NoSuchActivityException {
772                    return getPersistence()
773                                       .findByClassNameId_First(classNameId, orderByComparator);
774            }
775    
776            /**
777            * Returns the first social activity in the ordered set where classNameId = &#63;.
778            *
779            * @param classNameId the class name ID
780            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
781            * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found
782            */
783            public static SocialActivity fetchByClassNameId_First(long classNameId,
784                    OrderByComparator<SocialActivity> orderByComparator) {
785                    return getPersistence()
786                                       .fetchByClassNameId_First(classNameId, orderByComparator);
787            }
788    
789            /**
790            * Returns the last social activity in the ordered set where classNameId = &#63;.
791            *
792            * @param classNameId the class name ID
793            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
794            * @return the last matching social activity
795            * @throws NoSuchActivityException if a matching social activity could not be found
796            */
797            public static SocialActivity findByClassNameId_Last(long classNameId,
798                    OrderByComparator<SocialActivity> orderByComparator)
799                    throws com.liferay.portlet.social.NoSuchActivityException {
800                    return getPersistence()
801                                       .findByClassNameId_Last(classNameId, orderByComparator);
802            }
803    
804            /**
805            * Returns the last social activity in the ordered set where classNameId = &#63;.
806            *
807            * @param classNameId the class name ID
808            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
809            * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found
810            */
811            public static SocialActivity fetchByClassNameId_Last(long classNameId,
812                    OrderByComparator<SocialActivity> orderByComparator) {
813                    return getPersistence()
814                                       .fetchByClassNameId_Last(classNameId, orderByComparator);
815            }
816    
817            /**
818            * Returns the social activities before and after the current social activity in the ordered set where classNameId = &#63;.
819            *
820            * @param activityId the primary key of the current social activity
821            * @param classNameId the class name ID
822            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
823            * @return the previous, current, and next social activity
824            * @throws NoSuchActivityException if a social activity with the primary key could not be found
825            */
826            public static SocialActivity[] findByClassNameId_PrevAndNext(
827                    long activityId, long classNameId,
828                    OrderByComparator<SocialActivity> orderByComparator)
829                    throws com.liferay.portlet.social.NoSuchActivityException {
830                    return getPersistence()
831                                       .findByClassNameId_PrevAndNext(activityId, classNameId,
832                            orderByComparator);
833            }
834    
835            /**
836            * Removes all the social activities where classNameId = &#63; from the database.
837            *
838            * @param classNameId the class name ID
839            */
840            public static void removeByClassNameId(long classNameId) {
841                    getPersistence().removeByClassNameId(classNameId);
842            }
843    
844            /**
845            * Returns the number of social activities where classNameId = &#63;.
846            *
847            * @param classNameId the class name ID
848            * @return the number of matching social activities
849            */
850            public static int countByClassNameId(long classNameId) {
851                    return getPersistence().countByClassNameId(classNameId);
852            }
853    
854            /**
855            * Returns all the social activities where receiverUserId = &#63;.
856            *
857            * @param receiverUserId the receiver user ID
858            * @return the matching social activities
859            */
860            public static List<SocialActivity> findByReceiverUserId(long receiverUserId) {
861                    return getPersistence().findByReceiverUserId(receiverUserId);
862            }
863    
864            /**
865            * Returns a range of all the social activities where receiverUserId = &#63;.
866            *
867            * <p>
868            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 SocialActivityModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
869            * </p>
870            *
871            * @param receiverUserId the receiver user ID
872            * @param start the lower bound of the range of social activities
873            * @param end the upper bound of the range of social activities (not inclusive)
874            * @return the range of matching social activities
875            */
876            public static List<SocialActivity> findByReceiverUserId(
877                    long receiverUserId, int start, int end) {
878                    return getPersistence().findByReceiverUserId(receiverUserId, start, end);
879            }
880    
881            /**
882            * Returns an ordered range of all the social activities where receiverUserId = &#63;.
883            *
884            * <p>
885            * 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 SocialActivityModelImpl}. 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.
886            * </p>
887            *
888            * @param receiverUserId the receiver user ID
889            * @param start the lower bound of the range of social activities
890            * @param end the upper bound of the range of social activities (not inclusive)
891            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
892            * @return the ordered range of matching social activities
893            */
894            public static List<SocialActivity> findByReceiverUserId(
895                    long receiverUserId, int start, int end,
896                    OrderByComparator<SocialActivity> orderByComparator) {
897                    return getPersistence()
898                                       .findByReceiverUserId(receiverUserId, start, end,
899                            orderByComparator);
900            }
901    
902            /**
903            * Returns the first social activity in the ordered set where receiverUserId = &#63;.
904            *
905            * @param receiverUserId the receiver user ID
906            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
907            * @return the first matching social activity
908            * @throws NoSuchActivityException if a matching social activity could not be found
909            */
910            public static SocialActivity findByReceiverUserId_First(
911                    long receiverUserId, OrderByComparator<SocialActivity> orderByComparator)
912                    throws com.liferay.portlet.social.NoSuchActivityException {
913                    return getPersistence()
914                                       .findByReceiverUserId_First(receiverUserId, orderByComparator);
915            }
916    
917            /**
918            * Returns the first social activity in the ordered set where receiverUserId = &#63;.
919            *
920            * @param receiverUserId the receiver user ID
921            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
922            * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found
923            */
924            public static SocialActivity fetchByReceiverUserId_First(
925                    long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) {
926                    return getPersistence()
927                                       .fetchByReceiverUserId_First(receiverUserId,
928                            orderByComparator);
929            }
930    
931            /**
932            * Returns the last social activity in the ordered set where receiverUserId = &#63;.
933            *
934            * @param receiverUserId the receiver user ID
935            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
936            * @return the last matching social activity
937            * @throws NoSuchActivityException if a matching social activity could not be found
938            */
939            public static SocialActivity findByReceiverUserId_Last(
940                    long receiverUserId, OrderByComparator<SocialActivity> orderByComparator)
941                    throws com.liferay.portlet.social.NoSuchActivityException {
942                    return getPersistence()
943                                       .findByReceiverUserId_Last(receiverUserId, orderByComparator);
944            }
945    
946            /**
947            * Returns the last social activity in the ordered set where receiverUserId = &#63;.
948            *
949            * @param receiverUserId the receiver user ID
950            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
951            * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found
952            */
953            public static SocialActivity fetchByReceiverUserId_Last(
954                    long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) {
955                    return getPersistence()
956                                       .fetchByReceiverUserId_Last(receiverUserId, orderByComparator);
957            }
958    
959            /**
960            * Returns the social activities before and after the current social activity in the ordered set where receiverUserId = &#63;.
961            *
962            * @param activityId the primary key of the current social activity
963            * @param receiverUserId the receiver user ID
964            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
965            * @return the previous, current, and next social activity
966            * @throws NoSuchActivityException if a social activity with the primary key could not be found
967            */
968            public static SocialActivity[] findByReceiverUserId_PrevAndNext(
969                    long activityId, long receiverUserId,
970                    OrderByComparator<SocialActivity> orderByComparator)
971                    throws com.liferay.portlet.social.NoSuchActivityException {
972                    return getPersistence()
973                                       .findByReceiverUserId_PrevAndNext(activityId,
974                            receiverUserId, orderByComparator);
975            }
976    
977            /**
978            * Removes all the social activities where receiverUserId = &#63; from the database.
979            *
980            * @param receiverUserId the receiver user ID
981            */
982            public static void removeByReceiverUserId(long receiverUserId) {
983                    getPersistence().removeByReceiverUserId(receiverUserId);
984            }
985    
986            /**
987            * Returns the number of social activities where receiverUserId = &#63;.
988            *
989            * @param receiverUserId the receiver user ID
990            * @return the number of matching social activities
991            */
992            public static int countByReceiverUserId(long receiverUserId) {
993                    return getPersistence().countByReceiverUserId(receiverUserId);
994            }
995    
996            /**
997            * Returns all the social activities where classNameId = &#63; and classPK = &#63;.
998            *
999            * @param classNameId the class name ID
1000            * @param classPK the class p k
1001            * @return the matching social activities
1002            */
1003            public static List<SocialActivity> findByC_C(long classNameId, long classPK) {
1004                    return getPersistence().findByC_C(classNameId, classPK);
1005            }
1006    
1007            /**
1008            * Returns a range of all the social activities where classNameId = &#63; and classPK = &#63;.
1009            *
1010            * <p>
1011            * 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 SocialActivityModelImpl}. 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.
1012            * </p>
1013            *
1014            * @param classNameId the class name ID
1015            * @param classPK the class p k
1016            * @param start the lower bound of the range of social activities
1017            * @param end the upper bound of the range of social activities (not inclusive)
1018            * @return the range of matching social activities
1019            */
1020            public static List<SocialActivity> findByC_C(long classNameId,
1021                    long classPK, int start, int end) {
1022                    return getPersistence().findByC_C(classNameId, classPK, start, end);
1023            }
1024    
1025            /**
1026            * Returns an ordered range of all the social activities where classNameId = &#63; and classPK = &#63;.
1027            *
1028            * <p>
1029            * 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 SocialActivityModelImpl}. 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.
1030            * </p>
1031            *
1032            * @param classNameId the class name ID
1033            * @param classPK the class p k
1034            * @param start the lower bound of the range of social activities
1035            * @param end the upper bound of the range of social activities (not inclusive)
1036            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1037            * @return the ordered range of matching social activities
1038            */
1039            public static List<SocialActivity> findByC_C(long classNameId,
1040                    long classPK, int start, int end,
1041                    OrderByComparator<SocialActivity> orderByComparator) {
1042                    return getPersistence()
1043                                       .findByC_C(classNameId, classPK, start, end,
1044                            orderByComparator);
1045            }
1046    
1047            /**
1048            * Returns the first social activity in the ordered set where classNameId = &#63; and classPK = &#63;.
1049            *
1050            * @param classNameId the class name ID
1051            * @param classPK the class p k
1052            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1053            * @return the first matching social activity
1054            * @throws NoSuchActivityException if a matching social activity could not be found
1055            */
1056            public static SocialActivity findByC_C_First(long classNameId,
1057                    long classPK, OrderByComparator<SocialActivity> orderByComparator)
1058                    throws com.liferay.portlet.social.NoSuchActivityException {
1059                    return getPersistence()
1060                                       .findByC_C_First(classNameId, classPK, orderByComparator);
1061            }
1062    
1063            /**
1064            * Returns the first social activity in the ordered set where classNameId = &#63; and classPK = &#63;.
1065            *
1066            * @param classNameId the class name ID
1067            * @param classPK the class p k
1068            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1069            * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found
1070            */
1071            public static SocialActivity fetchByC_C_First(long classNameId,
1072                    long classPK, OrderByComparator<SocialActivity> orderByComparator) {
1073                    return getPersistence()
1074                                       .fetchByC_C_First(classNameId, classPK, orderByComparator);
1075            }
1076    
1077            /**
1078            * Returns the last social activity in the ordered set where classNameId = &#63; and classPK = &#63;.
1079            *
1080            * @param classNameId the class name ID
1081            * @param classPK the class p k
1082            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1083            * @return the last matching social activity
1084            * @throws NoSuchActivityException if a matching social activity could not be found
1085            */
1086            public static SocialActivity findByC_C_Last(long classNameId, long classPK,
1087                    OrderByComparator<SocialActivity> orderByComparator)
1088                    throws com.liferay.portlet.social.NoSuchActivityException {
1089                    return getPersistence()
1090                                       .findByC_C_Last(classNameId, classPK, orderByComparator);
1091            }
1092    
1093            /**
1094            * Returns the last social activity in the ordered set where classNameId = &#63; and classPK = &#63;.
1095            *
1096            * @param classNameId the class name ID
1097            * @param classPK the class p k
1098            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1099            * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found
1100            */
1101            public static SocialActivity fetchByC_C_Last(long classNameId,
1102                    long classPK, OrderByComparator<SocialActivity> orderByComparator) {
1103                    return getPersistence()
1104                                       .fetchByC_C_Last(classNameId, classPK, orderByComparator);
1105            }
1106    
1107            /**
1108            * Returns the social activities before and after the current social activity in the ordered set where classNameId = &#63; and classPK = &#63;.
1109            *
1110            * @param activityId the primary key of the current social activity
1111            * @param classNameId the class name ID
1112            * @param classPK the class p k
1113            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1114            * @return the previous, current, and next social activity
1115            * @throws NoSuchActivityException if a social activity with the primary key could not be found
1116            */
1117            public static SocialActivity[] findByC_C_PrevAndNext(long activityId,
1118                    long classNameId, long classPK,
1119                    OrderByComparator<SocialActivity> orderByComparator)
1120                    throws com.liferay.portlet.social.NoSuchActivityException {
1121                    return getPersistence()
1122                                       .findByC_C_PrevAndNext(activityId, classNameId, classPK,
1123                            orderByComparator);
1124            }
1125    
1126            /**
1127            * Removes all the social activities where classNameId = &#63; and classPK = &#63; from the database.
1128            *
1129            * @param classNameId the class name ID
1130            * @param classPK the class p k
1131            */
1132            public static void removeByC_C(long classNameId, long classPK) {
1133                    getPersistence().removeByC_C(classNameId, classPK);
1134            }
1135    
1136            /**
1137            * Returns the number of social activities where classNameId = &#63; and classPK = &#63;.
1138            *
1139            * @param classNameId the class name ID
1140            * @param classPK the class p k
1141            * @return the number of matching social activities
1142            */
1143            public static int countByC_C(long classNameId, long classPK) {
1144                    return getPersistence().countByC_C(classNameId, classPK);
1145            }
1146    
1147            /**
1148            * Returns all the social activities where mirrorActivityId = &#63; and classNameId = &#63; and classPK = &#63;.
1149            *
1150            * @param mirrorActivityId the mirror activity ID
1151            * @param classNameId the class name ID
1152            * @param classPK the class p k
1153            * @return the matching social activities
1154            */
1155            public static List<SocialActivity> findByM_C_C(long mirrorActivityId,
1156                    long classNameId, long classPK) {
1157                    return getPersistence()
1158                                       .findByM_C_C(mirrorActivityId, classNameId, classPK);
1159            }
1160    
1161            /**
1162            * Returns a range of all the social activities where mirrorActivityId = &#63; and classNameId = &#63; and classPK = &#63;.
1163            *
1164            * <p>
1165            * 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 SocialActivityModelImpl}. 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.
1166            * </p>
1167            *
1168            * @param mirrorActivityId the mirror activity ID
1169            * @param classNameId the class name ID
1170            * @param classPK the class p k
1171            * @param start the lower bound of the range of social activities
1172            * @param end the upper bound of the range of social activities (not inclusive)
1173            * @return the range of matching social activities
1174            */
1175            public static List<SocialActivity> findByM_C_C(long mirrorActivityId,
1176                    long classNameId, long classPK, int start, int end) {
1177                    return getPersistence()
1178                                       .findByM_C_C(mirrorActivityId, classNameId, classPK, start,
1179                            end);
1180            }
1181    
1182            /**
1183            * Returns an ordered range of all the social activities where mirrorActivityId = &#63; and classNameId = &#63; and classPK = &#63;.
1184            *
1185            * <p>
1186            * 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 SocialActivityModelImpl}. 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.
1187            * </p>
1188            *
1189            * @param mirrorActivityId the mirror activity ID
1190            * @param classNameId the class name ID
1191            * @param classPK the class p k
1192            * @param start the lower bound of the range of social activities
1193            * @param end the upper bound of the range of social activities (not inclusive)
1194            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1195            * @return the ordered range of matching social activities
1196            */
1197            public static List<SocialActivity> findByM_C_C(long mirrorActivityId,
1198                    long classNameId, long classPK, int start, int end,
1199                    OrderByComparator<SocialActivity> orderByComparator) {
1200                    return getPersistence()
1201                                       .findByM_C_C(mirrorActivityId, classNameId, classPK, start,
1202                            end, orderByComparator);
1203            }
1204    
1205            /**
1206            * Returns the first social activity in the ordered set where mirrorActivityId = &#63; and classNameId = &#63; and classPK = &#63;.
1207            *
1208            * @param mirrorActivityId the mirror activity ID
1209            * @param classNameId the class name ID
1210            * @param classPK the class p k
1211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1212            * @return the first matching social activity
1213            * @throws NoSuchActivityException if a matching social activity could not be found
1214            */
1215            public static SocialActivity findByM_C_C_First(long mirrorActivityId,
1216                    long classNameId, long classPK,
1217                    OrderByComparator<SocialActivity> orderByComparator)
1218                    throws com.liferay.portlet.social.NoSuchActivityException {
1219                    return getPersistence()
1220                                       .findByM_C_C_First(mirrorActivityId, classNameId, classPK,
1221                            orderByComparator);
1222            }
1223    
1224            /**
1225            * Returns the first social activity in the ordered set where mirrorActivityId = &#63; and classNameId = &#63; and classPK = &#63;.
1226            *
1227            * @param mirrorActivityId the mirror activity ID
1228            * @param classNameId the class name ID
1229            * @param classPK the class p k
1230            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1231            * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found
1232            */
1233            public static SocialActivity fetchByM_C_C_First(long mirrorActivityId,
1234                    long classNameId, long classPK,
1235                    OrderByComparator<SocialActivity> orderByComparator) {
1236                    return getPersistence()
1237                                       .fetchByM_C_C_First(mirrorActivityId, classNameId, classPK,
1238                            orderByComparator);
1239            }
1240    
1241            /**
1242            * Returns the last social activity in the ordered set where mirrorActivityId = &#63; and classNameId = &#63; and classPK = &#63;.
1243            *
1244            * @param mirrorActivityId the mirror activity ID
1245            * @param classNameId the class name ID
1246            * @param classPK the class p k
1247            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1248            * @return the last matching social activity
1249            * @throws NoSuchActivityException if a matching social activity could not be found
1250            */
1251            public static SocialActivity findByM_C_C_Last(long mirrorActivityId,
1252                    long classNameId, long classPK,
1253                    OrderByComparator<SocialActivity> orderByComparator)
1254                    throws com.liferay.portlet.social.NoSuchActivityException {
1255                    return getPersistence()
1256                                       .findByM_C_C_Last(mirrorActivityId, classNameId, classPK,
1257                            orderByComparator);
1258            }
1259    
1260            /**
1261            * Returns the last social activity in the ordered set where mirrorActivityId = &#63; and classNameId = &#63; and classPK = &#63;.
1262            *
1263            * @param mirrorActivityId the mirror activity ID
1264            * @param classNameId the class name ID
1265            * @param classPK the class p k
1266            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1267            * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found
1268            */
1269            public static SocialActivity fetchByM_C_C_Last(long mirrorActivityId,
1270                    long classNameId, long classPK,
1271                    OrderByComparator<SocialActivity> orderByComparator) {
1272                    return getPersistence()
1273                                       .fetchByM_C_C_Last(mirrorActivityId, classNameId, classPK,
1274                            orderByComparator);
1275            }
1276    
1277            /**
1278            * Returns the social activities before and after the current social activity in the ordered set where mirrorActivityId = &#63; and classNameId = &#63; and classPK = &#63;.
1279            *
1280            * @param activityId the primary key of the current social activity
1281            * @param mirrorActivityId the mirror activity ID
1282            * @param classNameId the class name ID
1283            * @param classPK the class p k
1284            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1285            * @return the previous, current, and next social activity
1286            * @throws NoSuchActivityException if a social activity with the primary key could not be found
1287            */
1288            public static SocialActivity[] findByM_C_C_PrevAndNext(long activityId,
1289                    long mirrorActivityId, long classNameId, long classPK,
1290                    OrderByComparator<SocialActivity> orderByComparator)
1291                    throws com.liferay.portlet.social.NoSuchActivityException {
1292                    return getPersistence()
1293                                       .findByM_C_C_PrevAndNext(activityId, mirrorActivityId,
1294                            classNameId, classPK, orderByComparator);
1295            }
1296    
1297            /**
1298            * Removes all the social activities where mirrorActivityId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
1299            *
1300            * @param mirrorActivityId the mirror activity ID
1301            * @param classNameId the class name ID
1302            * @param classPK the class p k
1303            */
1304            public static void removeByM_C_C(long mirrorActivityId, long classNameId,
1305                    long classPK) {
1306                    getPersistence().removeByM_C_C(mirrorActivityId, classNameId, classPK);
1307            }
1308    
1309            /**
1310            * Returns the number of social activities where mirrorActivityId = &#63; and classNameId = &#63; and classPK = &#63;.
1311            *
1312            * @param mirrorActivityId the mirror activity ID
1313            * @param classNameId the class name ID
1314            * @param classPK the class p k
1315            * @return the number of matching social activities
1316            */
1317            public static int countByM_C_C(long mirrorActivityId, long classNameId,
1318                    long classPK) {
1319                    return getPersistence()
1320                                       .countByM_C_C(mirrorActivityId, classNameId, classPK);
1321            }
1322    
1323            /**
1324            * Returns all the social activities where classNameId = &#63; and classPK = &#63; and type = &#63;.
1325            *
1326            * @param classNameId the class name ID
1327            * @param classPK the class p k
1328            * @param type the type
1329            * @return the matching social activities
1330            */
1331            public static List<SocialActivity> findByC_C_T(long classNameId,
1332                    long classPK, int type) {
1333                    return getPersistence().findByC_C_T(classNameId, classPK, type);
1334            }
1335    
1336            /**
1337            * Returns a range of all the social activities where classNameId = &#63; and classPK = &#63; and type = &#63;.
1338            *
1339            * <p>
1340            * 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 SocialActivityModelImpl}. 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.
1341            * </p>
1342            *
1343            * @param classNameId the class name ID
1344            * @param classPK the class p k
1345            * @param type the type
1346            * @param start the lower bound of the range of social activities
1347            * @param end the upper bound of the range of social activities (not inclusive)
1348            * @return the range of matching social activities
1349            */
1350            public static List<SocialActivity> findByC_C_T(long classNameId,
1351                    long classPK, int type, int start, int end) {
1352                    return getPersistence()
1353                                       .findByC_C_T(classNameId, classPK, type, start, end);
1354            }
1355    
1356            /**
1357            * Returns an ordered range of all the social activities where classNameId = &#63; and classPK = &#63; and type = &#63;.
1358            *
1359            * <p>
1360            * 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 SocialActivityModelImpl}. 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.
1361            * </p>
1362            *
1363            * @param classNameId the class name ID
1364            * @param classPK the class p k
1365            * @param type the type
1366            * @param start the lower bound of the range of social activities
1367            * @param end the upper bound of the range of social activities (not inclusive)
1368            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1369            * @return the ordered range of matching social activities
1370            */
1371            public static List<SocialActivity> findByC_C_T(long classNameId,
1372                    long classPK, int type, int start, int end,
1373                    OrderByComparator<SocialActivity> orderByComparator) {
1374                    return getPersistence()
1375                                       .findByC_C_T(classNameId, classPK, type, start, end,
1376                            orderByComparator);
1377            }
1378    
1379            /**
1380            * Returns the first social activity in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
1381            *
1382            * @param classNameId the class name ID
1383            * @param classPK the class p k
1384            * @param type the type
1385            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1386            * @return the first matching social activity
1387            * @throws NoSuchActivityException if a matching social activity could not be found
1388            */
1389            public static SocialActivity findByC_C_T_First(long classNameId,
1390                    long classPK, int type,
1391                    OrderByComparator<SocialActivity> orderByComparator)
1392                    throws com.liferay.portlet.social.NoSuchActivityException {
1393                    return getPersistence()
1394                                       .findByC_C_T_First(classNameId, classPK, type,
1395                            orderByComparator);
1396            }
1397    
1398            /**
1399            * Returns the first social activity in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
1400            *
1401            * @param classNameId the class name ID
1402            * @param classPK the class p k
1403            * @param type the type
1404            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1405            * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found
1406            */
1407            public static SocialActivity fetchByC_C_T_First(long classNameId,
1408                    long classPK, int type,
1409                    OrderByComparator<SocialActivity> orderByComparator) {
1410                    return getPersistence()
1411                                       .fetchByC_C_T_First(classNameId, classPK, type,
1412                            orderByComparator);
1413            }
1414    
1415            /**
1416            * Returns the last social activity in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
1417            *
1418            * @param classNameId the class name ID
1419            * @param classPK the class p k
1420            * @param type the type
1421            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1422            * @return the last matching social activity
1423            * @throws NoSuchActivityException if a matching social activity could not be found
1424            */
1425            public static SocialActivity findByC_C_T_Last(long classNameId,
1426                    long classPK, int type,
1427                    OrderByComparator<SocialActivity> orderByComparator)
1428                    throws com.liferay.portlet.social.NoSuchActivityException {
1429                    return getPersistence()
1430                                       .findByC_C_T_Last(classNameId, classPK, type,
1431                            orderByComparator);
1432            }
1433    
1434            /**
1435            * Returns the last social activity in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
1436            *
1437            * @param classNameId the class name ID
1438            * @param classPK the class p k
1439            * @param type the type
1440            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1441            * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found
1442            */
1443            public static SocialActivity fetchByC_C_T_Last(long classNameId,
1444                    long classPK, int type,
1445                    OrderByComparator<SocialActivity> orderByComparator) {
1446                    return getPersistence()
1447                                       .fetchByC_C_T_Last(classNameId, classPK, type,
1448                            orderByComparator);
1449            }
1450    
1451            /**
1452            * Returns the social activities before and after the current social activity in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
1453            *
1454            * @param activityId the primary key of the current social activity
1455            * @param classNameId the class name ID
1456            * @param classPK the class p k
1457            * @param type the type
1458            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1459            * @return the previous, current, and next social activity
1460            * @throws NoSuchActivityException if a social activity with the primary key could not be found
1461            */
1462            public static SocialActivity[] findByC_C_T_PrevAndNext(long activityId,
1463                    long classNameId, long classPK, int type,
1464                    OrderByComparator<SocialActivity> orderByComparator)
1465                    throws com.liferay.portlet.social.NoSuchActivityException {
1466                    return getPersistence()
1467                                       .findByC_C_T_PrevAndNext(activityId, classNameId, classPK,
1468                            type, orderByComparator);
1469            }
1470    
1471            /**
1472            * Removes all the social activities where classNameId = &#63; and classPK = &#63; and type = &#63; from the database.
1473            *
1474            * @param classNameId the class name ID
1475            * @param classPK the class p k
1476            * @param type the type
1477            */
1478            public static void removeByC_C_T(long classNameId, long classPK, int type) {
1479                    getPersistence().removeByC_C_T(classNameId, classPK, type);
1480            }
1481    
1482            /**
1483            * Returns the number of social activities where classNameId = &#63; and classPK = &#63; and type = &#63;.
1484            *
1485            * @param classNameId the class name ID
1486            * @param classPK the class p k
1487            * @param type the type
1488            * @return the number of matching social activities
1489            */
1490            public static int countByC_C_T(long classNameId, long classPK, int type) {
1491                    return getPersistence().countByC_C_T(classNameId, classPK, type);
1492            }
1493    
1494            /**
1495            * Returns all the social activities where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1496            *
1497            * @param groupId the group ID
1498            * @param userId the user ID
1499            * @param classNameId the class name ID
1500            * @param classPK the class p k
1501            * @param type the type
1502            * @param receiverUserId the receiver user ID
1503            * @return the matching social activities
1504            */
1505            public static List<SocialActivity> findByG_U_C_C_T_R(long groupId,
1506                    long userId, long classNameId, long classPK, int type,
1507                    long receiverUserId) {
1508                    return getPersistence()
1509                                       .findByG_U_C_C_T_R(groupId, userId, classNameId, classPK,
1510                            type, receiverUserId);
1511            }
1512    
1513            /**
1514            * Returns a range of all the social activities where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1515            *
1516            * <p>
1517            * 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 SocialActivityModelImpl}. 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.
1518            * </p>
1519            *
1520            * @param groupId the group ID
1521            * @param userId the user ID
1522            * @param classNameId the class name ID
1523            * @param classPK the class p k
1524            * @param type the type
1525            * @param receiverUserId the receiver user ID
1526            * @param start the lower bound of the range of social activities
1527            * @param end the upper bound of the range of social activities (not inclusive)
1528            * @return the range of matching social activities
1529            */
1530            public static List<SocialActivity> findByG_U_C_C_T_R(long groupId,
1531                    long userId, long classNameId, long classPK, int type,
1532                    long receiverUserId, int start, int end) {
1533                    return getPersistence()
1534                                       .findByG_U_C_C_T_R(groupId, userId, classNameId, classPK,
1535                            type, receiverUserId, start, end);
1536            }
1537    
1538            /**
1539            * Returns an ordered range of all the social activities where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1540            *
1541            * <p>
1542            * 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 SocialActivityModelImpl}. 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.
1543            * </p>
1544            *
1545            * @param groupId the group ID
1546            * @param userId the user ID
1547            * @param classNameId the class name ID
1548            * @param classPK the class p k
1549            * @param type the type
1550            * @param receiverUserId the receiver user ID
1551            * @param start the lower bound of the range of social activities
1552            * @param end the upper bound of the range of social activities (not inclusive)
1553            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1554            * @return the ordered range of matching social activities
1555            */
1556            public static List<SocialActivity> findByG_U_C_C_T_R(long groupId,
1557                    long userId, long classNameId, long classPK, int type,
1558                    long receiverUserId, int start, int end,
1559                    OrderByComparator<SocialActivity> orderByComparator) {
1560                    return getPersistence()
1561                                       .findByG_U_C_C_T_R(groupId, userId, classNameId, classPK,
1562                            type, receiverUserId, start, end, orderByComparator);
1563            }
1564    
1565            /**
1566            * Returns the first social activity in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1567            *
1568            * @param groupId the group ID
1569            * @param userId the user ID
1570            * @param classNameId the class name ID
1571            * @param classPK the class p k
1572            * @param type the type
1573            * @param receiverUserId the receiver user ID
1574            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1575            * @return the first matching social activity
1576            * @throws NoSuchActivityException if a matching social activity could not be found
1577            */
1578            public static SocialActivity findByG_U_C_C_T_R_First(long groupId,
1579                    long userId, long classNameId, long classPK, int type,
1580                    long receiverUserId, OrderByComparator<SocialActivity> orderByComparator)
1581                    throws com.liferay.portlet.social.NoSuchActivityException {
1582                    return getPersistence()
1583                                       .findByG_U_C_C_T_R_First(groupId, userId, classNameId,
1584                            classPK, type, receiverUserId, orderByComparator);
1585            }
1586    
1587            /**
1588            * Returns the first social activity in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1589            *
1590            * @param groupId the group ID
1591            * @param userId the user ID
1592            * @param classNameId the class name ID
1593            * @param classPK the class p k
1594            * @param type the type
1595            * @param receiverUserId the receiver user ID
1596            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1597            * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found
1598            */
1599            public static SocialActivity fetchByG_U_C_C_T_R_First(long groupId,
1600                    long userId, long classNameId, long classPK, int type,
1601                    long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) {
1602                    return getPersistence()
1603                                       .fetchByG_U_C_C_T_R_First(groupId, userId, classNameId,
1604                            classPK, type, receiverUserId, orderByComparator);
1605            }
1606    
1607            /**
1608            * Returns the last social activity in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1609            *
1610            * @param groupId the group ID
1611            * @param userId the user ID
1612            * @param classNameId the class name ID
1613            * @param classPK the class p k
1614            * @param type the type
1615            * @param receiverUserId the receiver user ID
1616            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1617            * @return the last matching social activity
1618            * @throws NoSuchActivityException if a matching social activity could not be found
1619            */
1620            public static SocialActivity findByG_U_C_C_T_R_Last(long groupId,
1621                    long userId, long classNameId, long classPK, int type,
1622                    long receiverUserId, OrderByComparator<SocialActivity> orderByComparator)
1623                    throws com.liferay.portlet.social.NoSuchActivityException {
1624                    return getPersistence()
1625                                       .findByG_U_C_C_T_R_Last(groupId, userId, classNameId,
1626                            classPK, type, receiverUserId, orderByComparator);
1627            }
1628    
1629            /**
1630            * Returns the last social activity in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1631            *
1632            * @param groupId the group ID
1633            * @param userId the user ID
1634            * @param classNameId the class name ID
1635            * @param classPK the class p k
1636            * @param type the type
1637            * @param receiverUserId the receiver user ID
1638            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1639            * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found
1640            */
1641            public static SocialActivity fetchByG_U_C_C_T_R_Last(long groupId,
1642                    long userId, long classNameId, long classPK, int type,
1643                    long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) {
1644                    return getPersistence()
1645                                       .fetchByG_U_C_C_T_R_Last(groupId, userId, classNameId,
1646                            classPK, type, receiverUserId, orderByComparator);
1647            }
1648    
1649            /**
1650            * Returns the social activities before and after the current social activity in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1651            *
1652            * @param activityId the primary key of the current social activity
1653            * @param groupId the group ID
1654            * @param userId the user ID
1655            * @param classNameId the class name ID
1656            * @param classPK the class p k
1657            * @param type the type
1658            * @param receiverUserId the receiver user ID
1659            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1660            * @return the previous, current, and next social activity
1661            * @throws NoSuchActivityException if a social activity with the primary key could not be found
1662            */
1663            public static SocialActivity[] findByG_U_C_C_T_R_PrevAndNext(
1664                    long activityId, long groupId, long userId, long classNameId,
1665                    long classPK, int type, long receiverUserId,
1666                    OrderByComparator<SocialActivity> orderByComparator)
1667                    throws com.liferay.portlet.social.NoSuchActivityException {
1668                    return getPersistence()
1669                                       .findByG_U_C_C_T_R_PrevAndNext(activityId, groupId, userId,
1670                            classNameId, classPK, type, receiverUserId, orderByComparator);
1671            }
1672    
1673            /**
1674            * Removes all the social activities where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; from the database.
1675            *
1676            * @param groupId the group ID
1677            * @param userId the user ID
1678            * @param classNameId the class name ID
1679            * @param classPK the class p k
1680            * @param type the type
1681            * @param receiverUserId the receiver user ID
1682            */
1683            public static void removeByG_U_C_C_T_R(long groupId, long userId,
1684                    long classNameId, long classPK, int type, long receiverUserId) {
1685                    getPersistence()
1686                            .removeByG_U_C_C_T_R(groupId, userId, classNameId, classPK, type,
1687                            receiverUserId);
1688            }
1689    
1690            /**
1691            * Returns the number of social activities where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1692            *
1693            * @param groupId the group ID
1694            * @param userId the user ID
1695            * @param classNameId the class name ID
1696            * @param classPK the class p k
1697            * @param type the type
1698            * @param receiverUserId the receiver user ID
1699            * @return the number of matching social activities
1700            */
1701            public static int countByG_U_C_C_T_R(long groupId, long userId,
1702                    long classNameId, long classPK, int type, long receiverUserId) {
1703                    return getPersistence()
1704                                       .countByG_U_C_C_T_R(groupId, userId, classNameId, classPK,
1705                            type, receiverUserId);
1706            }
1707    
1708            /**
1709            * Returns the social activity where groupId = &#63; and userId = &#63; and createDate = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; or throws a {@link NoSuchActivityException} if it could not be found.
1710            *
1711            * @param groupId the group ID
1712            * @param userId the user ID
1713            * @param createDate the create date
1714            * @param classNameId the class name ID
1715            * @param classPK the class p k
1716            * @param type the type
1717            * @param receiverUserId the receiver user ID
1718            * @return the matching social activity
1719            * @throws NoSuchActivityException if a matching social activity could not be found
1720            */
1721            public static SocialActivity findByG_U_CD_C_C_T_R(long groupId,
1722                    long userId, long createDate, long classNameId, long classPK, int type,
1723                    long receiverUserId)
1724                    throws com.liferay.portlet.social.NoSuchActivityException {
1725                    return getPersistence()
1726                                       .findByG_U_CD_C_C_T_R(groupId, userId, createDate,
1727                            classNameId, classPK, type, receiverUserId);
1728            }
1729    
1730            /**
1731            * Returns the social activity where groupId = &#63; and userId = &#63; and createDate = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1732            *
1733            * @param groupId the group ID
1734            * @param userId the user ID
1735            * @param createDate the create date
1736            * @param classNameId the class name ID
1737            * @param classPK the class p k
1738            * @param type the type
1739            * @param receiverUserId the receiver user ID
1740            * @return the matching social activity, or <code>null</code> if a matching social activity could not be found
1741            */
1742            public static SocialActivity fetchByG_U_CD_C_C_T_R(long groupId,
1743                    long userId, long createDate, long classNameId, long classPK, int type,
1744                    long receiverUserId) {
1745                    return getPersistence()
1746                                       .fetchByG_U_CD_C_C_T_R(groupId, userId, createDate,
1747                            classNameId, classPK, type, receiverUserId);
1748            }
1749    
1750            /**
1751            * Returns the social activity where groupId = &#63; and userId = &#63; and createDate = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1752            *
1753            * @param groupId the group ID
1754            * @param userId the user ID
1755            * @param createDate the create date
1756            * @param classNameId the class name ID
1757            * @param classPK the class p k
1758            * @param type the type
1759            * @param receiverUserId the receiver user ID
1760            * @param retrieveFromCache whether to use the finder cache
1761            * @return the matching social activity, or <code>null</code> if a matching social activity could not be found
1762            */
1763            public static SocialActivity fetchByG_U_CD_C_C_T_R(long groupId,
1764                    long userId, long createDate, long classNameId, long classPK, int type,
1765                    long receiverUserId, boolean retrieveFromCache) {
1766                    return getPersistence()
1767                                       .fetchByG_U_CD_C_C_T_R(groupId, userId, createDate,
1768                            classNameId, classPK, type, receiverUserId, retrieveFromCache);
1769            }
1770    
1771            /**
1772            * Removes the social activity where groupId = &#63; and userId = &#63; and createDate = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; from the database.
1773            *
1774            * @param groupId the group ID
1775            * @param userId the user ID
1776            * @param createDate the create date
1777            * @param classNameId the class name ID
1778            * @param classPK the class p k
1779            * @param type the type
1780            * @param receiverUserId the receiver user ID
1781            * @return the social activity that was removed
1782            */
1783            public static SocialActivity removeByG_U_CD_C_C_T_R(long groupId,
1784                    long userId, long createDate, long classNameId, long classPK, int type,
1785                    long receiverUserId)
1786                    throws com.liferay.portlet.social.NoSuchActivityException {
1787                    return getPersistence()
1788                                       .removeByG_U_CD_C_C_T_R(groupId, userId, createDate,
1789                            classNameId, classPK, type, receiverUserId);
1790            }
1791    
1792            /**
1793            * Returns the number of social activities where groupId = &#63; and userId = &#63; and createDate = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1794            *
1795            * @param groupId the group ID
1796            * @param userId the user ID
1797            * @param createDate the create date
1798            * @param classNameId the class name ID
1799            * @param classPK the class p k
1800            * @param type the type
1801            * @param receiverUserId the receiver user ID
1802            * @return the number of matching social activities
1803            */
1804            public static int countByG_U_CD_C_C_T_R(long groupId, long userId,
1805                    long createDate, long classNameId, long classPK, int type,
1806                    long receiverUserId) {
1807                    return getPersistence()
1808                                       .countByG_U_CD_C_C_T_R(groupId, userId, createDate,
1809                            classNameId, classPK, type, receiverUserId);
1810            }
1811    
1812            /**
1813            * Caches the social activity in the entity cache if it is enabled.
1814            *
1815            * @param socialActivity the social activity
1816            */
1817            public static void cacheResult(SocialActivity socialActivity) {
1818                    getPersistence().cacheResult(socialActivity);
1819            }
1820    
1821            /**
1822            * Caches the social activities in the entity cache if it is enabled.
1823            *
1824            * @param socialActivities the social activities
1825            */
1826            public static void cacheResult(List<SocialActivity> socialActivities) {
1827                    getPersistence().cacheResult(socialActivities);
1828            }
1829    
1830            /**
1831            * Creates a new social activity with the primary key. Does not add the social activity to the database.
1832            *
1833            * @param activityId the primary key for the new social activity
1834            * @return the new social activity
1835            */
1836            public static SocialActivity create(long activityId) {
1837                    return getPersistence().create(activityId);
1838            }
1839    
1840            /**
1841            * Removes the social activity with the primary key from the database. Also notifies the appropriate model listeners.
1842            *
1843            * @param activityId the primary key of the social activity
1844            * @return the social activity that was removed
1845            * @throws NoSuchActivityException if a social activity with the primary key could not be found
1846            */
1847            public static SocialActivity remove(long activityId)
1848                    throws com.liferay.portlet.social.NoSuchActivityException {
1849                    return getPersistence().remove(activityId);
1850            }
1851    
1852            public static SocialActivity updateImpl(SocialActivity socialActivity) {
1853                    return getPersistence().updateImpl(socialActivity);
1854            }
1855    
1856            /**
1857            * Returns the social activity with the primary key or throws a {@link NoSuchActivityException} if it could not be found.
1858            *
1859            * @param activityId the primary key of the social activity
1860            * @return the social activity
1861            * @throws NoSuchActivityException if a social activity with the primary key could not be found
1862            */
1863            public static SocialActivity findByPrimaryKey(long activityId)
1864                    throws com.liferay.portlet.social.NoSuchActivityException {
1865                    return getPersistence().findByPrimaryKey(activityId);
1866            }
1867    
1868            /**
1869            * Returns the social activity with the primary key or returns <code>null</code> if it could not be found.
1870            *
1871            * @param activityId the primary key of the social activity
1872            * @return the social activity, or <code>null</code> if a social activity with the primary key could not be found
1873            */
1874            public static SocialActivity fetchByPrimaryKey(long activityId) {
1875                    return getPersistence().fetchByPrimaryKey(activityId);
1876            }
1877    
1878            public static java.util.Map<java.io.Serializable, SocialActivity> fetchByPrimaryKeys(
1879                    java.util.Set<java.io.Serializable> primaryKeys) {
1880                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1881            }
1882    
1883            /**
1884            * Returns all the social activities.
1885            *
1886            * @return the social activities
1887            */
1888            public static List<SocialActivity> findAll() {
1889                    return getPersistence().findAll();
1890            }
1891    
1892            /**
1893            * Returns a range of all the social activities.
1894            *
1895            * <p>
1896            * 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 SocialActivityModelImpl}. 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.
1897            * </p>
1898            *
1899            * @param start the lower bound of the range of social activities
1900            * @param end the upper bound of the range of social activities (not inclusive)
1901            * @return the range of social activities
1902            */
1903            public static List<SocialActivity> findAll(int start, int end) {
1904                    return getPersistence().findAll(start, end);
1905            }
1906    
1907            /**
1908            * Returns an ordered range of all the social activities.
1909            *
1910            * <p>
1911            * 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 SocialActivityModelImpl}. 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.
1912            * </p>
1913            *
1914            * @param start the lower bound of the range of social activities
1915            * @param end the upper bound of the range of social activities (not inclusive)
1916            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1917            * @return the ordered range of social activities
1918            */
1919            public static List<SocialActivity> findAll(int start, int end,
1920                    OrderByComparator<SocialActivity> orderByComparator) {
1921                    return getPersistence().findAll(start, end, orderByComparator);
1922            }
1923    
1924            /**
1925            * Removes all the social activities from the database.
1926            */
1927            public static void removeAll() {
1928                    getPersistence().removeAll();
1929            }
1930    
1931            /**
1932            * Returns the number of social activities.
1933            *
1934            * @return the number of social activities
1935            */
1936            public static int countAll() {
1937                    return getPersistence().countAll();
1938            }
1939    
1940            public static SocialActivityPersistence getPersistence() {
1941                    if (_persistence == null) {
1942                            _persistence = (SocialActivityPersistence)PortalBeanLocatorUtil.locate(SocialActivityPersistence.class.getName());
1943    
1944                            ReferenceRegistry.registerReference(SocialActivityUtil.class,
1945                                    "_persistence");
1946                    }
1947    
1948                    return _persistence;
1949            }
1950    
1951            /**
1952             * @deprecated As of 6.2.0
1953             */
1954            @Deprecated
1955            public void setPersistence(SocialActivityPersistence persistence) {
1956            }
1957    
1958            private static SocialActivityPersistence _persistence;
1959    }