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.service.persistence.BasePersistence;
020    
021    import com.liferay.portlet.social.exception.NoSuchActivityLimitException;
022    import com.liferay.portlet.social.model.SocialActivityLimit;
023    
024    /**
025     * The persistence interface for the social activity limit service.
026     *
027     * <p>
028     * Caching information and settings can be found in <code>portal.properties</code>
029     * </p>
030     *
031     * @author Brian Wing Shun Chan
032     * @see com.liferay.portlet.social.service.persistence.impl.SocialActivityLimitPersistenceImpl
033     * @see SocialActivityLimitUtil
034     * @generated
035     */
036    @ProviderType
037    public interface SocialActivityLimitPersistence extends BasePersistence<SocialActivityLimit> {
038            /*
039             * NOTE FOR DEVELOPERS:
040             *
041             * Never modify or reference this interface directly. Always use {@link SocialActivityLimitUtil} to access the social activity limit persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
042             */
043    
044            /**
045            * Returns all the social activity limits where groupId = &#63;.
046            *
047            * @param groupId the group ID
048            * @return the matching social activity limits
049            */
050            public java.util.List<SocialActivityLimit> findByGroupId(long groupId);
051    
052            /**
053            * Returns a range of all the social activity limits where groupId = &#63;.
054            *
055            * <p>
056            * 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 SocialActivityLimitModelImpl}. 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.
057            * </p>
058            *
059            * @param groupId the group ID
060            * @param start the lower bound of the range of social activity limits
061            * @param end the upper bound of the range of social activity limits (not inclusive)
062            * @return the range of matching social activity limits
063            */
064            public java.util.List<SocialActivityLimit> findByGroupId(long groupId,
065                    int start, int end);
066    
067            /**
068            * Returns an ordered range of all the social activity limits where groupId = &#63;.
069            *
070            * <p>
071            * 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 SocialActivityLimitModelImpl}. 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.
072            * </p>
073            *
074            * @param groupId the group ID
075            * @param start the lower bound of the range of social activity limits
076            * @param end the upper bound of the range of social activity limits (not inclusive)
077            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
078            * @return the ordered range of matching social activity limits
079            */
080            public java.util.List<SocialActivityLimit> findByGroupId(long groupId,
081                    int start, int end,
082                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator);
083    
084            /**
085            * Returns an ordered range of all the social activity limits where groupId = &#63;.
086            *
087            * <p>
088            * 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 SocialActivityLimitModelImpl}. 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.
089            * </p>
090            *
091            * @param groupId the group ID
092            * @param start the lower bound of the range of social activity limits
093            * @param end the upper bound of the range of social activity limits (not inclusive)
094            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
095            * @param retrieveFromCache whether to retrieve from the finder cache
096            * @return the ordered range of matching social activity limits
097            */
098            public java.util.List<SocialActivityLimit> findByGroupId(long groupId,
099                    int start, int end,
100                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator,
101                    boolean retrieveFromCache);
102    
103            /**
104            * Returns the first social activity limit in the ordered set where groupId = &#63;.
105            *
106            * @param groupId the group ID
107            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
108            * @return the first matching social activity limit
109            * @throws NoSuchActivityLimitException if a matching social activity limit could not be found
110            */
111            public SocialActivityLimit findByGroupId_First(long groupId,
112                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator)
113                    throws NoSuchActivityLimitException;
114    
115            /**
116            * Returns the first social activity limit in the ordered set where groupId = &#63;.
117            *
118            * @param groupId the group ID
119            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
120            * @return the first matching social activity limit, or <code>null</code> if a matching social activity limit could not be found
121            */
122            public SocialActivityLimit fetchByGroupId_First(long groupId,
123                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator);
124    
125            /**
126            * Returns the last social activity limit in the ordered set where groupId = &#63;.
127            *
128            * @param groupId the group ID
129            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
130            * @return the last matching social activity limit
131            * @throws NoSuchActivityLimitException if a matching social activity limit could not be found
132            */
133            public SocialActivityLimit findByGroupId_Last(long groupId,
134                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator)
135                    throws NoSuchActivityLimitException;
136    
137            /**
138            * Returns the last social activity limit in the ordered set where groupId = &#63;.
139            *
140            * @param groupId the group ID
141            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
142            * @return the last matching social activity limit, or <code>null</code> if a matching social activity limit could not be found
143            */
144            public SocialActivityLimit fetchByGroupId_Last(long groupId,
145                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator);
146    
147            /**
148            * Returns the social activity limits before and after the current social activity limit in the ordered set where groupId = &#63;.
149            *
150            * @param activityLimitId the primary key of the current social activity limit
151            * @param groupId the group ID
152            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
153            * @return the previous, current, and next social activity limit
154            * @throws NoSuchActivityLimitException if a social activity limit with the primary key could not be found
155            */
156            public SocialActivityLimit[] findByGroupId_PrevAndNext(
157                    long activityLimitId, long groupId,
158                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator)
159                    throws NoSuchActivityLimitException;
160    
161            /**
162            * Removes all the social activity limits where groupId = &#63; from the database.
163            *
164            * @param groupId the group ID
165            */
166            public void removeByGroupId(long groupId);
167    
168            /**
169            * Returns the number of social activity limits where groupId = &#63;.
170            *
171            * @param groupId the group ID
172            * @return the number of matching social activity limits
173            */
174            public int countByGroupId(long groupId);
175    
176            /**
177            * Returns all the social activity limits where userId = &#63;.
178            *
179            * @param userId the user ID
180            * @return the matching social activity limits
181            */
182            public java.util.List<SocialActivityLimit> findByUserId(long userId);
183    
184            /**
185            * Returns a range of all the social activity limits where userId = &#63;.
186            *
187            * <p>
188            * 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 SocialActivityLimitModelImpl}. 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.
189            * </p>
190            *
191            * @param userId the user ID
192            * @param start the lower bound of the range of social activity limits
193            * @param end the upper bound of the range of social activity limits (not inclusive)
194            * @return the range of matching social activity limits
195            */
196            public java.util.List<SocialActivityLimit> findByUserId(long userId,
197                    int start, int end);
198    
199            /**
200            * Returns an ordered range of all the social activity limits where userId = &#63;.
201            *
202            * <p>
203            * 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 SocialActivityLimitModelImpl}. 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.
204            * </p>
205            *
206            * @param userId the user ID
207            * @param start the lower bound of the range of social activity limits
208            * @param end the upper bound of the range of social activity limits (not inclusive)
209            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
210            * @return the ordered range of matching social activity limits
211            */
212            public java.util.List<SocialActivityLimit> findByUserId(long userId,
213                    int start, int end,
214                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator);
215    
216            /**
217            * Returns an ordered range of all the social activity limits where userId = &#63;.
218            *
219            * <p>
220            * 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 SocialActivityLimitModelImpl}. 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.
221            * </p>
222            *
223            * @param userId the user ID
224            * @param start the lower bound of the range of social activity limits
225            * @param end the upper bound of the range of social activity limits (not inclusive)
226            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
227            * @param retrieveFromCache whether to retrieve from the finder cache
228            * @return the ordered range of matching social activity limits
229            */
230            public java.util.List<SocialActivityLimit> findByUserId(long userId,
231                    int start, int end,
232                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator,
233                    boolean retrieveFromCache);
234    
235            /**
236            * Returns the first social activity limit in the ordered set where userId = &#63;.
237            *
238            * @param userId the user ID
239            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
240            * @return the first matching social activity limit
241            * @throws NoSuchActivityLimitException if a matching social activity limit could not be found
242            */
243            public SocialActivityLimit findByUserId_First(long userId,
244                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator)
245                    throws NoSuchActivityLimitException;
246    
247            /**
248            * Returns the first social activity limit in the ordered set where userId = &#63;.
249            *
250            * @param userId the user ID
251            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
252            * @return the first matching social activity limit, or <code>null</code> if a matching social activity limit could not be found
253            */
254            public SocialActivityLimit fetchByUserId_First(long userId,
255                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator);
256    
257            /**
258            * Returns the last social activity limit in the ordered set where userId = &#63;.
259            *
260            * @param userId the user ID
261            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
262            * @return the last matching social activity limit
263            * @throws NoSuchActivityLimitException if a matching social activity limit could not be found
264            */
265            public SocialActivityLimit findByUserId_Last(long userId,
266                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator)
267                    throws NoSuchActivityLimitException;
268    
269            /**
270            * Returns the last social activity limit in the ordered set where userId = &#63;.
271            *
272            * @param userId the user ID
273            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
274            * @return the last matching social activity limit, or <code>null</code> if a matching social activity limit could not be found
275            */
276            public SocialActivityLimit fetchByUserId_Last(long userId,
277                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator);
278    
279            /**
280            * Returns the social activity limits before and after the current social activity limit in the ordered set where userId = &#63;.
281            *
282            * @param activityLimitId the primary key of the current social activity limit
283            * @param userId the user ID
284            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
285            * @return the previous, current, and next social activity limit
286            * @throws NoSuchActivityLimitException if a social activity limit with the primary key could not be found
287            */
288            public SocialActivityLimit[] findByUserId_PrevAndNext(
289                    long activityLimitId, long userId,
290                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator)
291                    throws NoSuchActivityLimitException;
292    
293            /**
294            * Removes all the social activity limits where userId = &#63; from the database.
295            *
296            * @param userId the user ID
297            */
298            public void removeByUserId(long userId);
299    
300            /**
301            * Returns the number of social activity limits where userId = &#63;.
302            *
303            * @param userId the user ID
304            * @return the number of matching social activity limits
305            */
306            public int countByUserId(long userId);
307    
308            /**
309            * Returns all the social activity limits where classNameId = &#63; and classPK = &#63;.
310            *
311            * @param classNameId the class name ID
312            * @param classPK the class p k
313            * @return the matching social activity limits
314            */
315            public java.util.List<SocialActivityLimit> findByC_C(long classNameId,
316                    long classPK);
317    
318            /**
319            * Returns a range of all the social activity limits where classNameId = &#63; and classPK = &#63;.
320            *
321            * <p>
322            * 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 SocialActivityLimitModelImpl}. 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.
323            * </p>
324            *
325            * @param classNameId the class name ID
326            * @param classPK the class p k
327            * @param start the lower bound of the range of social activity limits
328            * @param end the upper bound of the range of social activity limits (not inclusive)
329            * @return the range of matching social activity limits
330            */
331            public java.util.List<SocialActivityLimit> findByC_C(long classNameId,
332                    long classPK, int start, int end);
333    
334            /**
335            * Returns an ordered range of all the social activity limits where classNameId = &#63; and classPK = &#63;.
336            *
337            * <p>
338            * 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 SocialActivityLimitModelImpl}. 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.
339            * </p>
340            *
341            * @param classNameId the class name ID
342            * @param classPK the class p k
343            * @param start the lower bound of the range of social activity limits
344            * @param end the upper bound of the range of social activity limits (not inclusive)
345            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
346            * @return the ordered range of matching social activity limits
347            */
348            public java.util.List<SocialActivityLimit> findByC_C(long classNameId,
349                    long classPK, int start, int end,
350                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator);
351    
352            /**
353            * Returns an ordered range of all the social activity limits where classNameId = &#63; and classPK = &#63;.
354            *
355            * <p>
356            * 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 SocialActivityLimitModelImpl}. 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.
357            * </p>
358            *
359            * @param classNameId the class name ID
360            * @param classPK the class p k
361            * @param start the lower bound of the range of social activity limits
362            * @param end the upper bound of the range of social activity limits (not inclusive)
363            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
364            * @param retrieveFromCache whether to retrieve from the finder cache
365            * @return the ordered range of matching social activity limits
366            */
367            public java.util.List<SocialActivityLimit> findByC_C(long classNameId,
368                    long classPK, int start, int end,
369                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator,
370                    boolean retrieveFromCache);
371    
372            /**
373            * Returns the first social activity limit in the ordered set where classNameId = &#63; and classPK = &#63;.
374            *
375            * @param classNameId the class name ID
376            * @param classPK the class p k
377            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
378            * @return the first matching social activity limit
379            * @throws NoSuchActivityLimitException if a matching social activity limit could not be found
380            */
381            public SocialActivityLimit findByC_C_First(long classNameId, long classPK,
382                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator)
383                    throws NoSuchActivityLimitException;
384    
385            /**
386            * Returns the first social activity limit in the ordered set where classNameId = &#63; and classPK = &#63;.
387            *
388            * @param classNameId the class name ID
389            * @param classPK the class p k
390            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
391            * @return the first matching social activity limit, or <code>null</code> if a matching social activity limit could not be found
392            */
393            public SocialActivityLimit fetchByC_C_First(long classNameId, long classPK,
394                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator);
395    
396            /**
397            * Returns the last social activity limit in the ordered set where classNameId = &#63; and classPK = &#63;.
398            *
399            * @param classNameId the class name ID
400            * @param classPK the class p k
401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
402            * @return the last matching social activity limit
403            * @throws NoSuchActivityLimitException if a matching social activity limit could not be found
404            */
405            public SocialActivityLimit findByC_C_Last(long classNameId, long classPK,
406                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator)
407                    throws NoSuchActivityLimitException;
408    
409            /**
410            * Returns the last social activity limit in the ordered set where classNameId = &#63; and classPK = &#63;.
411            *
412            * @param classNameId the class name ID
413            * @param classPK the class p k
414            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
415            * @return the last matching social activity limit, or <code>null</code> if a matching social activity limit could not be found
416            */
417            public SocialActivityLimit fetchByC_C_Last(long classNameId, long classPK,
418                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator);
419    
420            /**
421            * Returns the social activity limits before and after the current social activity limit in the ordered set where classNameId = &#63; and classPK = &#63;.
422            *
423            * @param activityLimitId the primary key of the current social activity limit
424            * @param classNameId the class name ID
425            * @param classPK the class p k
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the previous, current, and next social activity limit
428            * @throws NoSuchActivityLimitException if a social activity limit with the primary key could not be found
429            */
430            public SocialActivityLimit[] findByC_C_PrevAndNext(long activityLimitId,
431                    long classNameId, long classPK,
432                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator)
433                    throws NoSuchActivityLimitException;
434    
435            /**
436            * Removes all the social activity limits where classNameId = &#63; and classPK = &#63; from the database.
437            *
438            * @param classNameId the class name ID
439            * @param classPK the class p k
440            */
441            public void removeByC_C(long classNameId, long classPK);
442    
443            /**
444            * Returns the number of social activity limits where classNameId = &#63; and classPK = &#63;.
445            *
446            * @param classNameId the class name ID
447            * @param classPK the class p k
448            * @return the number of matching social activity limits
449            */
450            public int countByC_C(long classNameId, long classPK);
451    
452            /**
453            * Returns the social activity limit where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and activityType = &#63; and activityCounterName = &#63; or throws a {@link NoSuchActivityLimitException} if it could not be found.
454            *
455            * @param groupId the group ID
456            * @param userId the user ID
457            * @param classNameId the class name ID
458            * @param classPK the class p k
459            * @param activityType the activity type
460            * @param activityCounterName the activity counter name
461            * @return the matching social activity limit
462            * @throws NoSuchActivityLimitException if a matching social activity limit could not be found
463            */
464            public SocialActivityLimit findByG_U_C_C_A_A(long groupId, long userId,
465                    long classNameId, long classPK, int activityType,
466                    java.lang.String activityCounterName)
467                    throws NoSuchActivityLimitException;
468    
469            /**
470            * Returns the social activity limit where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and activityType = &#63; and activityCounterName = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
471            *
472            * @param groupId the group ID
473            * @param userId the user ID
474            * @param classNameId the class name ID
475            * @param classPK the class p k
476            * @param activityType the activity type
477            * @param activityCounterName the activity counter name
478            * @return the matching social activity limit, or <code>null</code> if a matching social activity limit could not be found
479            */
480            public SocialActivityLimit fetchByG_U_C_C_A_A(long groupId, long userId,
481                    long classNameId, long classPK, int activityType,
482                    java.lang.String activityCounterName);
483    
484            /**
485            * Returns the social activity limit where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and activityType = &#63; and activityCounterName = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
486            *
487            * @param groupId the group ID
488            * @param userId the user ID
489            * @param classNameId the class name ID
490            * @param classPK the class p k
491            * @param activityType the activity type
492            * @param activityCounterName the activity counter name
493            * @param retrieveFromCache whether to retrieve from the finder cache
494            * @return the matching social activity limit, or <code>null</code> if a matching social activity limit could not be found
495            */
496            public SocialActivityLimit fetchByG_U_C_C_A_A(long groupId, long userId,
497                    long classNameId, long classPK, int activityType,
498                    java.lang.String activityCounterName, boolean retrieveFromCache);
499    
500            /**
501            * Removes the social activity limit where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and activityType = &#63; and activityCounterName = &#63; from the database.
502            *
503            * @param groupId the group ID
504            * @param userId the user ID
505            * @param classNameId the class name ID
506            * @param classPK the class p k
507            * @param activityType the activity type
508            * @param activityCounterName the activity counter name
509            * @return the social activity limit that was removed
510            */
511            public SocialActivityLimit removeByG_U_C_C_A_A(long groupId, long userId,
512                    long classNameId, long classPK, int activityType,
513                    java.lang.String activityCounterName)
514                    throws NoSuchActivityLimitException;
515    
516            /**
517            * Returns the number of social activity limits where groupId = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; and activityType = &#63; and activityCounterName = &#63;.
518            *
519            * @param groupId the group ID
520            * @param userId the user ID
521            * @param classNameId the class name ID
522            * @param classPK the class p k
523            * @param activityType the activity type
524            * @param activityCounterName the activity counter name
525            * @return the number of matching social activity limits
526            */
527            public int countByG_U_C_C_A_A(long groupId, long userId, long classNameId,
528                    long classPK, int activityType, java.lang.String activityCounterName);
529    
530            /**
531            * Caches the social activity limit in the entity cache if it is enabled.
532            *
533            * @param socialActivityLimit the social activity limit
534            */
535            public void cacheResult(SocialActivityLimit socialActivityLimit);
536    
537            /**
538            * Caches the social activity limits in the entity cache if it is enabled.
539            *
540            * @param socialActivityLimits the social activity limits
541            */
542            public void cacheResult(
543                    java.util.List<SocialActivityLimit> socialActivityLimits);
544    
545            /**
546            * Creates a new social activity limit with the primary key. Does not add the social activity limit to the database.
547            *
548            * @param activityLimitId the primary key for the new social activity limit
549            * @return the new social activity limit
550            */
551            public SocialActivityLimit create(long activityLimitId);
552    
553            /**
554            * Removes the social activity limit with the primary key from the database. Also notifies the appropriate model listeners.
555            *
556            * @param activityLimitId the primary key of the social activity limit
557            * @return the social activity limit that was removed
558            * @throws NoSuchActivityLimitException if a social activity limit with the primary key could not be found
559            */
560            public SocialActivityLimit remove(long activityLimitId)
561                    throws NoSuchActivityLimitException;
562    
563            public SocialActivityLimit updateImpl(
564                    SocialActivityLimit socialActivityLimit);
565    
566            /**
567            * Returns the social activity limit with the primary key or throws a {@link NoSuchActivityLimitException} if it could not be found.
568            *
569            * @param activityLimitId the primary key of the social activity limit
570            * @return the social activity limit
571            * @throws NoSuchActivityLimitException if a social activity limit with the primary key could not be found
572            */
573            public SocialActivityLimit findByPrimaryKey(long activityLimitId)
574                    throws NoSuchActivityLimitException;
575    
576            /**
577            * Returns the social activity limit with the primary key or returns <code>null</code> if it could not be found.
578            *
579            * @param activityLimitId the primary key of the social activity limit
580            * @return the social activity limit, or <code>null</code> if a social activity limit with the primary key could not be found
581            */
582            public SocialActivityLimit fetchByPrimaryKey(long activityLimitId);
583    
584            @Override
585            public java.util.Map<java.io.Serializable, SocialActivityLimit> fetchByPrimaryKeys(
586                    java.util.Set<java.io.Serializable> primaryKeys);
587    
588            /**
589            * Returns all the social activity limits.
590            *
591            * @return the social activity limits
592            */
593            public java.util.List<SocialActivityLimit> findAll();
594    
595            /**
596            * Returns a range of all the social activity limits.
597            *
598            * <p>
599            * 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 SocialActivityLimitModelImpl}. 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.
600            * </p>
601            *
602            * @param start the lower bound of the range of social activity limits
603            * @param end the upper bound of the range of social activity limits (not inclusive)
604            * @return the range of social activity limits
605            */
606            public java.util.List<SocialActivityLimit> findAll(int start, int end);
607    
608            /**
609            * Returns an ordered range of all the social activity limits.
610            *
611            * <p>
612            * 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 SocialActivityLimitModelImpl}. 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.
613            * </p>
614            *
615            * @param start the lower bound of the range of social activity limits
616            * @param end the upper bound of the range of social activity limits (not inclusive)
617            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
618            * @return the ordered range of social activity limits
619            */
620            public java.util.List<SocialActivityLimit> findAll(int start, int end,
621                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator);
622    
623            /**
624            * Returns an ordered range of all the social activity limits.
625            *
626            * <p>
627            * 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 SocialActivityLimitModelImpl}. 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.
628            * </p>
629            *
630            * @param start the lower bound of the range of social activity limits
631            * @param end the upper bound of the range of social activity limits (not inclusive)
632            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
633            * @param retrieveFromCache whether to retrieve from the finder cache
634            * @return the ordered range of social activity limits
635            */
636            public java.util.List<SocialActivityLimit> findAll(int start, int end,
637                    com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator,
638                    boolean retrieveFromCache);
639    
640            /**
641            * Removes all the social activity limits from the database.
642            */
643            public void removeAll();
644    
645            /**
646            * Returns the number of social activity limits.
647            *
648            * @return the number of social activity limits
649            */
650            public int countAll();
651    }