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