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.calendar.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.service.persistence.BasePersistence;
020    
021    import com.liferay.portlet.calendar.exception.NoSuchEventException;
022    import com.liferay.portlet.calendar.model.CalEvent;
023    
024    /**
025     * The persistence interface for the cal event 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.calendar.service.persistence.impl.CalEventPersistenceImpl
033     * @see CalEventUtil
034     * @deprecated As of 7.0.0, with no direct replacement
035     * @generated
036     */
037    @Deprecated
038    @ProviderType
039    public interface CalEventPersistence extends BasePersistence<CalEvent> {
040            /*
041             * NOTE FOR DEVELOPERS:
042             *
043             * Never modify or reference this interface directly. Always use {@link CalEventUtil} to access the cal event persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
044             */
045    
046            /**
047            * Returns all the cal events where uuid = &#63;.
048            *
049            * @param uuid the uuid
050            * @return the matching cal events
051            */
052            public java.util.List<CalEvent> findByUuid(java.lang.String uuid);
053    
054            /**
055            * Returns a range of all the cal events where uuid = &#63;.
056            *
057            * <p>
058            * 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 CalEventModelImpl}. 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.
059            * </p>
060            *
061            * @param uuid the uuid
062            * @param start the lower bound of the range of cal events
063            * @param end the upper bound of the range of cal events (not inclusive)
064            * @return the range of matching cal events
065            */
066            public java.util.List<CalEvent> findByUuid(java.lang.String uuid,
067                    int start, int end);
068    
069            /**
070            * Returns an ordered range of all the cal events where uuid = &#63;.
071            *
072            * <p>
073            * 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 CalEventModelImpl}. 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.
074            * </p>
075            *
076            * @param uuid the uuid
077            * @param start the lower bound of the range of cal events
078            * @param end the upper bound of the range of cal events (not inclusive)
079            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
080            * @return the ordered range of matching cal events
081            */
082            public java.util.List<CalEvent> findByUuid(java.lang.String uuid,
083                    int start, int end,
084                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
085    
086            /**
087            * Returns an ordered range of all the cal events where uuid = &#63;.
088            *
089            * <p>
090            * 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 CalEventModelImpl}. 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.
091            * </p>
092            *
093            * @param uuid the uuid
094            * @param start the lower bound of the range of cal events
095            * @param end the upper bound of the range of cal events (not inclusive)
096            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
097            * @param retrieveFromCache whether to retrieve from the finder cache
098            * @return the ordered range of matching cal events
099            */
100            public java.util.List<CalEvent> findByUuid(java.lang.String uuid,
101                    int start, int end,
102                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
103                    boolean retrieveFromCache);
104    
105            /**
106            * Returns the first cal event in the ordered set where uuid = &#63;.
107            *
108            * @param uuid the uuid
109            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
110            * @return the first matching cal event
111            * @throws NoSuchEventException if a matching cal event could not be found
112            */
113            public CalEvent findByUuid_First(java.lang.String uuid,
114                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
115                    throws NoSuchEventException;
116    
117            /**
118            * Returns the first cal event in the ordered set where uuid = &#63;.
119            *
120            * @param uuid the uuid
121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
122            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
123            */
124            public CalEvent fetchByUuid_First(java.lang.String uuid,
125                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
126    
127            /**
128            * Returns the last cal event in the ordered set where uuid = &#63;.
129            *
130            * @param uuid the uuid
131            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
132            * @return the last matching cal event
133            * @throws NoSuchEventException if a matching cal event could not be found
134            */
135            public CalEvent findByUuid_Last(java.lang.String uuid,
136                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
137                    throws NoSuchEventException;
138    
139            /**
140            * Returns the last cal event in the ordered set where uuid = &#63;.
141            *
142            * @param uuid the uuid
143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
144            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
145            */
146            public CalEvent fetchByUuid_Last(java.lang.String uuid,
147                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
148    
149            /**
150            * Returns the cal events before and after the current cal event in the ordered set where uuid = &#63;.
151            *
152            * @param eventId the primary key of the current cal event
153            * @param uuid the uuid
154            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
155            * @return the previous, current, and next cal event
156            * @throws NoSuchEventException if a cal event with the primary key could not be found
157            */
158            public CalEvent[] findByUuid_PrevAndNext(long eventId,
159                    java.lang.String uuid,
160                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
161                    throws NoSuchEventException;
162    
163            /**
164            * Removes all the cal events where uuid = &#63; from the database.
165            *
166            * @param uuid the uuid
167            */
168            public void removeByUuid(java.lang.String uuid);
169    
170            /**
171            * Returns the number of cal events where uuid = &#63;.
172            *
173            * @param uuid the uuid
174            * @return the number of matching cal events
175            */
176            public int countByUuid(java.lang.String uuid);
177    
178            /**
179            * Returns the cal event where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchEventException} if it could not be found.
180            *
181            * @param uuid the uuid
182            * @param groupId the group ID
183            * @return the matching cal event
184            * @throws NoSuchEventException if a matching cal event could not be found
185            */
186            public CalEvent findByUUID_G(java.lang.String uuid, long groupId)
187                    throws NoSuchEventException;
188    
189            /**
190            * Returns the cal event where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
191            *
192            * @param uuid the uuid
193            * @param groupId the group ID
194            * @return the matching cal event, or <code>null</code> if a matching cal event could not be found
195            */
196            public CalEvent fetchByUUID_G(java.lang.String uuid, long groupId);
197    
198            /**
199            * Returns the cal event where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
200            *
201            * @param uuid the uuid
202            * @param groupId the group ID
203            * @param retrieveFromCache whether to retrieve from the finder cache
204            * @return the matching cal event, or <code>null</code> if a matching cal event could not be found
205            */
206            public CalEvent fetchByUUID_G(java.lang.String uuid, long groupId,
207                    boolean retrieveFromCache);
208    
209            /**
210            * Removes the cal event where uuid = &#63; and groupId = &#63; from the database.
211            *
212            * @param uuid the uuid
213            * @param groupId the group ID
214            * @return the cal event that was removed
215            */
216            public CalEvent removeByUUID_G(java.lang.String uuid, long groupId)
217                    throws NoSuchEventException;
218    
219            /**
220            * Returns the number of cal events where uuid = &#63; and groupId = &#63;.
221            *
222            * @param uuid the uuid
223            * @param groupId the group ID
224            * @return the number of matching cal events
225            */
226            public int countByUUID_G(java.lang.String uuid, long groupId);
227    
228            /**
229            * Returns all the cal events where uuid = &#63; and companyId = &#63;.
230            *
231            * @param uuid the uuid
232            * @param companyId the company ID
233            * @return the matching cal events
234            */
235            public java.util.List<CalEvent> findByUuid_C(java.lang.String uuid,
236                    long companyId);
237    
238            /**
239            * Returns a range of all the cal events where uuid = &#63; and companyId = &#63;.
240            *
241            * <p>
242            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link CalEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
243            * </p>
244            *
245            * @param uuid the uuid
246            * @param companyId the company ID
247            * @param start the lower bound of the range of cal events
248            * @param end the upper bound of the range of cal events (not inclusive)
249            * @return the range of matching cal events
250            */
251            public java.util.List<CalEvent> findByUuid_C(java.lang.String uuid,
252                    long companyId, int start, int end);
253    
254            /**
255            * Returns an ordered range of all the cal events where uuid = &#63; and companyId = &#63;.
256            *
257            * <p>
258            * 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 CalEventModelImpl}. 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.
259            * </p>
260            *
261            * @param uuid the uuid
262            * @param companyId the company ID
263            * @param start the lower bound of the range of cal events
264            * @param end the upper bound of the range of cal events (not inclusive)
265            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
266            * @return the ordered range of matching cal events
267            */
268            public java.util.List<CalEvent> findByUuid_C(java.lang.String uuid,
269                    long companyId, int start, int end,
270                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
271    
272            /**
273            * Returns an ordered range of all the cal events where uuid = &#63; and companyId = &#63;.
274            *
275            * <p>
276            * 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 CalEventModelImpl}. 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.
277            * </p>
278            *
279            * @param uuid the uuid
280            * @param companyId the company ID
281            * @param start the lower bound of the range of cal events
282            * @param end the upper bound of the range of cal events (not inclusive)
283            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
284            * @param retrieveFromCache whether to retrieve from the finder cache
285            * @return the ordered range of matching cal events
286            */
287            public java.util.List<CalEvent> findByUuid_C(java.lang.String uuid,
288                    long companyId, int start, int end,
289                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
290                    boolean retrieveFromCache);
291    
292            /**
293            * Returns the first cal event in the ordered set where uuid = &#63; and companyId = &#63;.
294            *
295            * @param uuid the uuid
296            * @param companyId the company ID
297            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
298            * @return the first matching cal event
299            * @throws NoSuchEventException if a matching cal event could not be found
300            */
301            public CalEvent findByUuid_C_First(java.lang.String uuid, long companyId,
302                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
303                    throws NoSuchEventException;
304    
305            /**
306            * Returns the first cal event in the ordered set where uuid = &#63; and companyId = &#63;.
307            *
308            * @param uuid the uuid
309            * @param companyId the company ID
310            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
311            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
312            */
313            public CalEvent fetchByUuid_C_First(java.lang.String uuid, long companyId,
314                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
315    
316            /**
317            * Returns the last cal event in the ordered set where uuid = &#63; and companyId = &#63;.
318            *
319            * @param uuid the uuid
320            * @param companyId the company ID
321            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
322            * @return the last matching cal event
323            * @throws NoSuchEventException if a matching cal event could not be found
324            */
325            public CalEvent findByUuid_C_Last(java.lang.String uuid, long companyId,
326                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
327                    throws NoSuchEventException;
328    
329            /**
330            * Returns the last cal event in the ordered set where uuid = &#63; and companyId = &#63;.
331            *
332            * @param uuid the uuid
333            * @param companyId the company ID
334            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
335            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
336            */
337            public CalEvent fetchByUuid_C_Last(java.lang.String uuid, long companyId,
338                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
339    
340            /**
341            * Returns the cal events before and after the current cal event in the ordered set where uuid = &#63; and companyId = &#63;.
342            *
343            * @param eventId the primary key of the current cal event
344            * @param uuid the uuid
345            * @param companyId the company ID
346            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
347            * @return the previous, current, and next cal event
348            * @throws NoSuchEventException if a cal event with the primary key could not be found
349            */
350            public CalEvent[] findByUuid_C_PrevAndNext(long eventId,
351                    java.lang.String uuid, long companyId,
352                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
353                    throws NoSuchEventException;
354    
355            /**
356            * Removes all the cal events where uuid = &#63; and companyId = &#63; from the database.
357            *
358            * @param uuid the uuid
359            * @param companyId the company ID
360            */
361            public void removeByUuid_C(java.lang.String uuid, long companyId);
362    
363            /**
364            * Returns the number of cal events where uuid = &#63; and companyId = &#63;.
365            *
366            * @param uuid the uuid
367            * @param companyId the company ID
368            * @return the number of matching cal events
369            */
370            public int countByUuid_C(java.lang.String uuid, long companyId);
371    
372            /**
373            * Returns all the cal events where groupId = &#63;.
374            *
375            * @param groupId the group ID
376            * @return the matching cal events
377            */
378            public java.util.List<CalEvent> findByGroupId(long groupId);
379    
380            /**
381            * Returns a range of all the cal events where groupId = &#63;.
382            *
383            * <p>
384            * 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 CalEventModelImpl}. 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.
385            * </p>
386            *
387            * @param groupId the group ID
388            * @param start the lower bound of the range of cal events
389            * @param end the upper bound of the range of cal events (not inclusive)
390            * @return the range of matching cal events
391            */
392            public java.util.List<CalEvent> findByGroupId(long groupId, int start,
393                    int end);
394    
395            /**
396            * Returns an ordered range of all the cal events where groupId = &#63;.
397            *
398            * <p>
399            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link CalEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
400            * </p>
401            *
402            * @param groupId the group ID
403            * @param start the lower bound of the range of cal events
404            * @param end the upper bound of the range of cal events (not inclusive)
405            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
406            * @return the ordered range of matching cal events
407            */
408            public java.util.List<CalEvent> findByGroupId(long groupId, int start,
409                    int end,
410                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
411    
412            /**
413            * Returns an ordered range of all the cal events where groupId = &#63;.
414            *
415            * <p>
416            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link CalEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
417            * </p>
418            *
419            * @param groupId the group ID
420            * @param start the lower bound of the range of cal events
421            * @param end the upper bound of the range of cal events (not inclusive)
422            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
423            * @param retrieveFromCache whether to retrieve from the finder cache
424            * @return the ordered range of matching cal events
425            */
426            public java.util.List<CalEvent> findByGroupId(long groupId, int start,
427                    int end,
428                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
429                    boolean retrieveFromCache);
430    
431            /**
432            * Returns the first cal event in the ordered set where groupId = &#63;.
433            *
434            * @param groupId the group ID
435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
436            * @return the first matching cal event
437            * @throws NoSuchEventException if a matching cal event could not be found
438            */
439            public CalEvent findByGroupId_First(long groupId,
440                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
441                    throws NoSuchEventException;
442    
443            /**
444            * Returns the first cal event in the ordered set where groupId = &#63;.
445            *
446            * @param groupId the group ID
447            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
448            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
449            */
450            public CalEvent fetchByGroupId_First(long groupId,
451                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
452    
453            /**
454            * Returns the last cal event in the ordered set where groupId = &#63;.
455            *
456            * @param groupId the group ID
457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
458            * @return the last matching cal event
459            * @throws NoSuchEventException if a matching cal event could not be found
460            */
461            public CalEvent findByGroupId_Last(long groupId,
462                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
463                    throws NoSuchEventException;
464    
465            /**
466            * Returns the last cal event in the ordered set where groupId = &#63;.
467            *
468            * @param groupId the group ID
469            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
470            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
471            */
472            public CalEvent fetchByGroupId_Last(long groupId,
473                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
474    
475            /**
476            * Returns the cal events before and after the current cal event in the ordered set where groupId = &#63;.
477            *
478            * @param eventId the primary key of the current cal event
479            * @param groupId the group ID
480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
481            * @return the previous, current, and next cal event
482            * @throws NoSuchEventException if a cal event with the primary key could not be found
483            */
484            public CalEvent[] findByGroupId_PrevAndNext(long eventId, long groupId,
485                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
486                    throws NoSuchEventException;
487    
488            /**
489            * Removes all the cal events where groupId = &#63; from the database.
490            *
491            * @param groupId the group ID
492            */
493            public void removeByGroupId(long groupId);
494    
495            /**
496            * Returns the number of cal events where groupId = &#63;.
497            *
498            * @param groupId the group ID
499            * @return the number of matching cal events
500            */
501            public int countByGroupId(long groupId);
502    
503            /**
504            * Returns all the cal events where companyId = &#63;.
505            *
506            * @param companyId the company ID
507            * @return the matching cal events
508            */
509            public java.util.List<CalEvent> findByCompanyId(long companyId);
510    
511            /**
512            * Returns a range of all the cal events where companyId = &#63;.
513            *
514            * <p>
515            * 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 CalEventModelImpl}. 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.
516            * </p>
517            *
518            * @param companyId the company ID
519            * @param start the lower bound of the range of cal events
520            * @param end the upper bound of the range of cal events (not inclusive)
521            * @return the range of matching cal events
522            */
523            public java.util.List<CalEvent> findByCompanyId(long companyId, int start,
524                    int end);
525    
526            /**
527            * Returns an ordered range of all the cal events where companyId = &#63;.
528            *
529            * <p>
530            * 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 CalEventModelImpl}. 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.
531            * </p>
532            *
533            * @param companyId the company ID
534            * @param start the lower bound of the range of cal events
535            * @param end the upper bound of the range of cal events (not inclusive)
536            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
537            * @return the ordered range of matching cal events
538            */
539            public java.util.List<CalEvent> findByCompanyId(long companyId, int start,
540                    int end,
541                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
542    
543            /**
544            * Returns an ordered range of all the cal events where companyId = &#63;.
545            *
546            * <p>
547            * 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 CalEventModelImpl}. 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.
548            * </p>
549            *
550            * @param companyId the company ID
551            * @param start the lower bound of the range of cal events
552            * @param end the upper bound of the range of cal events (not inclusive)
553            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
554            * @param retrieveFromCache whether to retrieve from the finder cache
555            * @return the ordered range of matching cal events
556            */
557            public java.util.List<CalEvent> findByCompanyId(long companyId, int start,
558                    int end,
559                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
560                    boolean retrieveFromCache);
561    
562            /**
563            * Returns the first cal event in the ordered set where companyId = &#63;.
564            *
565            * @param companyId the company ID
566            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
567            * @return the first matching cal event
568            * @throws NoSuchEventException if a matching cal event could not be found
569            */
570            public CalEvent findByCompanyId_First(long companyId,
571                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
572                    throws NoSuchEventException;
573    
574            /**
575            * Returns the first cal event in the ordered set where companyId = &#63;.
576            *
577            * @param companyId the company ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
580            */
581            public CalEvent fetchByCompanyId_First(long companyId,
582                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
583    
584            /**
585            * Returns the last cal event in the ordered set where companyId = &#63;.
586            *
587            * @param companyId the company ID
588            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
589            * @return the last matching cal event
590            * @throws NoSuchEventException if a matching cal event could not be found
591            */
592            public CalEvent findByCompanyId_Last(long companyId,
593                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
594                    throws NoSuchEventException;
595    
596            /**
597            * Returns the last cal event in the ordered set where companyId = &#63;.
598            *
599            * @param companyId the company ID
600            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
601            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
602            */
603            public CalEvent fetchByCompanyId_Last(long companyId,
604                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
605    
606            /**
607            * Returns the cal events before and after the current cal event in the ordered set where companyId = &#63;.
608            *
609            * @param eventId the primary key of the current cal event
610            * @param companyId the company ID
611            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
612            * @return the previous, current, and next cal event
613            * @throws NoSuchEventException if a cal event with the primary key could not be found
614            */
615            public CalEvent[] findByCompanyId_PrevAndNext(long eventId, long companyId,
616                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
617                    throws NoSuchEventException;
618    
619            /**
620            * Removes all the cal events where companyId = &#63; from the database.
621            *
622            * @param companyId the company ID
623            */
624            public void removeByCompanyId(long companyId);
625    
626            /**
627            * Returns the number of cal events where companyId = &#63;.
628            *
629            * @param companyId the company ID
630            * @return the number of matching cal events
631            */
632            public int countByCompanyId(long companyId);
633    
634            /**
635            * Returns all the cal events where remindBy &ne; &#63;.
636            *
637            * @param remindBy the remind by
638            * @return the matching cal events
639            */
640            public java.util.List<CalEvent> findByNotRemindBy(int remindBy);
641    
642            /**
643            * Returns a range of all the cal events where remindBy &ne; &#63;.
644            *
645            * <p>
646            * 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 CalEventModelImpl}. 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.
647            * </p>
648            *
649            * @param remindBy the remind by
650            * @param start the lower bound of the range of cal events
651            * @param end the upper bound of the range of cal events (not inclusive)
652            * @return the range of matching cal events
653            */
654            public java.util.List<CalEvent> findByNotRemindBy(int remindBy, int start,
655                    int end);
656    
657            /**
658            * Returns an ordered range of all the cal events where remindBy &ne; &#63;.
659            *
660            * <p>
661            * 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 CalEventModelImpl}. 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.
662            * </p>
663            *
664            * @param remindBy the remind by
665            * @param start the lower bound of the range of cal events
666            * @param end the upper bound of the range of cal events (not inclusive)
667            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
668            * @return the ordered range of matching cal events
669            */
670            public java.util.List<CalEvent> findByNotRemindBy(int remindBy, int start,
671                    int end,
672                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
673    
674            /**
675            * Returns an ordered range of all the cal events where remindBy &ne; &#63;.
676            *
677            * <p>
678            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link CalEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
679            * </p>
680            *
681            * @param remindBy the remind by
682            * @param start the lower bound of the range of cal events
683            * @param end the upper bound of the range of cal events (not inclusive)
684            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
685            * @param retrieveFromCache whether to retrieve from the finder cache
686            * @return the ordered range of matching cal events
687            */
688            public java.util.List<CalEvent> findByNotRemindBy(int remindBy, int start,
689                    int end,
690                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
691                    boolean retrieveFromCache);
692    
693            /**
694            * Returns the first cal event in the ordered set where remindBy &ne; &#63;.
695            *
696            * @param remindBy the remind by
697            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
698            * @return the first matching cal event
699            * @throws NoSuchEventException if a matching cal event could not be found
700            */
701            public CalEvent findByNotRemindBy_First(int remindBy,
702                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
703                    throws NoSuchEventException;
704    
705            /**
706            * Returns the first cal event in the ordered set where remindBy &ne; &#63;.
707            *
708            * @param remindBy the remind by
709            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
710            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
711            */
712            public CalEvent fetchByNotRemindBy_First(int remindBy,
713                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
714    
715            /**
716            * Returns the last cal event in the ordered set where remindBy &ne; &#63;.
717            *
718            * @param remindBy the remind by
719            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
720            * @return the last matching cal event
721            * @throws NoSuchEventException if a matching cal event could not be found
722            */
723            public CalEvent findByNotRemindBy_Last(int remindBy,
724                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
725                    throws NoSuchEventException;
726    
727            /**
728            * Returns the last cal event in the ordered set where remindBy &ne; &#63;.
729            *
730            * @param remindBy the remind by
731            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
732            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
733            */
734            public CalEvent fetchByNotRemindBy_Last(int remindBy,
735                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
736    
737            /**
738            * Returns the cal events before and after the current cal event in the ordered set where remindBy &ne; &#63;.
739            *
740            * @param eventId the primary key of the current cal event
741            * @param remindBy the remind by
742            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
743            * @return the previous, current, and next cal event
744            * @throws NoSuchEventException if a cal event with the primary key could not be found
745            */
746            public CalEvent[] findByNotRemindBy_PrevAndNext(long eventId, int remindBy,
747                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
748                    throws NoSuchEventException;
749    
750            /**
751            * Removes all the cal events where remindBy &ne; &#63; from the database.
752            *
753            * @param remindBy the remind by
754            */
755            public void removeByNotRemindBy(int remindBy);
756    
757            /**
758            * Returns the number of cal events where remindBy &ne; &#63;.
759            *
760            * @param remindBy the remind by
761            * @return the number of matching cal events
762            */
763            public int countByNotRemindBy(int remindBy);
764    
765            /**
766            * Returns all the cal events where groupId = &#63; and type = &#63;.
767            *
768            * @param groupId the group ID
769            * @param type the type
770            * @return the matching cal events
771            */
772            public java.util.List<CalEvent> findByG_T(long groupId,
773                    java.lang.String type);
774    
775            /**
776            * Returns a range of all the cal events where groupId = &#63; and type = &#63;.
777            *
778            * <p>
779            * 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 CalEventModelImpl}. 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.
780            * </p>
781            *
782            * @param groupId the group ID
783            * @param type the type
784            * @param start the lower bound of the range of cal events
785            * @param end the upper bound of the range of cal events (not inclusive)
786            * @return the range of matching cal events
787            */
788            public java.util.List<CalEvent> findByG_T(long groupId,
789                    java.lang.String type, int start, int end);
790    
791            /**
792            * Returns an ordered range of all the cal events where groupId = &#63; and type = &#63;.
793            *
794            * <p>
795            * 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 CalEventModelImpl}. 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.
796            * </p>
797            *
798            * @param groupId the group ID
799            * @param type the type
800            * @param start the lower bound of the range of cal events
801            * @param end the upper bound of the range of cal events (not inclusive)
802            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
803            * @return the ordered range of matching cal events
804            */
805            public java.util.List<CalEvent> findByG_T(long groupId,
806                    java.lang.String type, int start, int end,
807                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
808    
809            /**
810            * Returns an ordered range of all the cal events where groupId = &#63; and type = &#63;.
811            *
812            * <p>
813            * 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 CalEventModelImpl}. 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.
814            * </p>
815            *
816            * @param groupId the group ID
817            * @param type the type
818            * @param start the lower bound of the range of cal events
819            * @param end the upper bound of the range of cal events (not inclusive)
820            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
821            * @param retrieveFromCache whether to retrieve from the finder cache
822            * @return the ordered range of matching cal events
823            */
824            public java.util.List<CalEvent> findByG_T(long groupId,
825                    java.lang.String type, int start, int end,
826                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
827                    boolean retrieveFromCache);
828    
829            /**
830            * Returns the first cal event in the ordered set where groupId = &#63; and type = &#63;.
831            *
832            * @param groupId the group ID
833            * @param type the type
834            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
835            * @return the first matching cal event
836            * @throws NoSuchEventException if a matching cal event could not be found
837            */
838            public CalEvent findByG_T_First(long groupId, java.lang.String type,
839                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
840                    throws NoSuchEventException;
841    
842            /**
843            * Returns the first cal event in the ordered set where groupId = &#63; and type = &#63;.
844            *
845            * @param groupId the group ID
846            * @param type the type
847            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
848            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
849            */
850            public CalEvent fetchByG_T_First(long groupId, java.lang.String type,
851                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
852    
853            /**
854            * Returns the last cal event in the ordered set where groupId = &#63; and type = &#63;.
855            *
856            * @param groupId the group ID
857            * @param type the type
858            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
859            * @return the last matching cal event
860            * @throws NoSuchEventException if a matching cal event could not be found
861            */
862            public CalEvent findByG_T_Last(long groupId, java.lang.String type,
863                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
864                    throws NoSuchEventException;
865    
866            /**
867            * Returns the last cal event in the ordered set where groupId = &#63; and type = &#63;.
868            *
869            * @param groupId the group ID
870            * @param type the type
871            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
872            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
873            */
874            public CalEvent fetchByG_T_Last(long groupId, java.lang.String type,
875                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
876    
877            /**
878            * Returns the cal events before and after the current cal event in the ordered set where groupId = &#63; and type = &#63;.
879            *
880            * @param eventId the primary key of the current cal event
881            * @param groupId the group ID
882            * @param type the type
883            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
884            * @return the previous, current, and next cal event
885            * @throws NoSuchEventException if a cal event with the primary key could not be found
886            */
887            public CalEvent[] findByG_T_PrevAndNext(long eventId, long groupId,
888                    java.lang.String type,
889                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
890                    throws NoSuchEventException;
891    
892            /**
893            * Returns all the cal events where groupId = &#63; and type = any &#63;.
894            *
895            * <p>
896            * 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 CalEventModelImpl}. 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.
897            * </p>
898            *
899            * @param groupId the group ID
900            * @param types the types
901            * @return the matching cal events
902            */
903            public java.util.List<CalEvent> findByG_T(long groupId,
904                    java.lang.String[] types);
905    
906            /**
907            * Returns a range of all the cal events where groupId = &#63; and type = any &#63;.
908            *
909            * <p>
910            * 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 CalEventModelImpl}. 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.
911            * </p>
912            *
913            * @param groupId the group ID
914            * @param types the types
915            * @param start the lower bound of the range of cal events
916            * @param end the upper bound of the range of cal events (not inclusive)
917            * @return the range of matching cal events
918            */
919            public java.util.List<CalEvent> findByG_T(long groupId,
920                    java.lang.String[] types, int start, int end);
921    
922            /**
923            * Returns an ordered range of all the cal events where groupId = &#63; and type = any &#63;.
924            *
925            * <p>
926            * 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 CalEventModelImpl}. 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.
927            * </p>
928            *
929            * @param groupId the group ID
930            * @param types the types
931            * @param start the lower bound of the range of cal events
932            * @param end the upper bound of the range of cal events (not inclusive)
933            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
934            * @return the ordered range of matching cal events
935            */
936            public java.util.List<CalEvent> findByG_T(long groupId,
937                    java.lang.String[] types, int start, int end,
938                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
939    
940            /**
941            * Returns an ordered range of all the cal events where groupId = &#63; and type = &#63;, optionally using the finder cache.
942            *
943            * <p>
944            * 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 CalEventModelImpl}. 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.
945            * </p>
946            *
947            * @param groupId the group ID
948            * @param type the type
949            * @param start the lower bound of the range of cal events
950            * @param end the upper bound of the range of cal events (not inclusive)
951            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
952            * @param retrieveFromCache whether to retrieve from the finder cache
953            * @return the ordered range of matching cal events
954            */
955            public java.util.List<CalEvent> findByG_T(long groupId,
956                    java.lang.String[] types, int start, int end,
957                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
958                    boolean retrieveFromCache);
959    
960            /**
961            * Removes all the cal events where groupId = &#63; and type = &#63; from the database.
962            *
963            * @param groupId the group ID
964            * @param type the type
965            */
966            public void removeByG_T(long groupId, java.lang.String type);
967    
968            /**
969            * Returns the number of cal events where groupId = &#63; and type = &#63;.
970            *
971            * @param groupId the group ID
972            * @param type the type
973            * @return the number of matching cal events
974            */
975            public int countByG_T(long groupId, java.lang.String type);
976    
977            /**
978            * Returns the number of cal events where groupId = &#63; and type = any &#63;.
979            *
980            * @param groupId the group ID
981            * @param types the types
982            * @return the number of matching cal events
983            */
984            public int countByG_T(long groupId, java.lang.String[] types);
985    
986            /**
987            * Returns all the cal events where groupId = &#63; and repeating = &#63;.
988            *
989            * @param groupId the group ID
990            * @param repeating the repeating
991            * @return the matching cal events
992            */
993            public java.util.List<CalEvent> findByG_R(long groupId, boolean repeating);
994    
995            /**
996            * Returns a range of all the cal events where groupId = &#63; and repeating = &#63;.
997            *
998            * <p>
999            * 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 CalEventModelImpl}. 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.
1000            * </p>
1001            *
1002            * @param groupId the group ID
1003            * @param repeating the repeating
1004            * @param start the lower bound of the range of cal events
1005            * @param end the upper bound of the range of cal events (not inclusive)
1006            * @return the range of matching cal events
1007            */
1008            public java.util.List<CalEvent> findByG_R(long groupId, boolean repeating,
1009                    int start, int end);
1010    
1011            /**
1012            * Returns an ordered range of all the cal events where groupId = &#63; and repeating = &#63;.
1013            *
1014            * <p>
1015            * 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 CalEventModelImpl}. 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.
1016            * </p>
1017            *
1018            * @param groupId the group ID
1019            * @param repeating the repeating
1020            * @param start the lower bound of the range of cal events
1021            * @param end the upper bound of the range of cal events (not inclusive)
1022            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1023            * @return the ordered range of matching cal events
1024            */
1025            public java.util.List<CalEvent> findByG_R(long groupId, boolean repeating,
1026                    int start, int end,
1027                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
1028    
1029            /**
1030            * Returns an ordered range of all the cal events where groupId = &#63; and repeating = &#63;.
1031            *
1032            * <p>
1033            * 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 CalEventModelImpl}. 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.
1034            * </p>
1035            *
1036            * @param groupId the group ID
1037            * @param repeating the repeating
1038            * @param start the lower bound of the range of cal events
1039            * @param end the upper bound of the range of cal events (not inclusive)
1040            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1041            * @param retrieveFromCache whether to retrieve from the finder cache
1042            * @return the ordered range of matching cal events
1043            */
1044            public java.util.List<CalEvent> findByG_R(long groupId, boolean repeating,
1045                    int start, int end,
1046                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
1047                    boolean retrieveFromCache);
1048    
1049            /**
1050            * Returns the first cal event in the ordered set where groupId = &#63; and repeating = &#63;.
1051            *
1052            * @param groupId the group ID
1053            * @param repeating the repeating
1054            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1055            * @return the first matching cal event
1056            * @throws NoSuchEventException if a matching cal event could not be found
1057            */
1058            public CalEvent findByG_R_First(long groupId, boolean repeating,
1059                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
1060                    throws NoSuchEventException;
1061    
1062            /**
1063            * Returns the first cal event in the ordered set where groupId = &#63; and repeating = &#63;.
1064            *
1065            * @param groupId the group ID
1066            * @param repeating the repeating
1067            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1068            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
1069            */
1070            public CalEvent fetchByG_R_First(long groupId, boolean repeating,
1071                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
1072    
1073            /**
1074            * Returns the last cal event in the ordered set where groupId = &#63; and repeating = &#63;.
1075            *
1076            * @param groupId the group ID
1077            * @param repeating the repeating
1078            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1079            * @return the last matching cal event
1080            * @throws NoSuchEventException if a matching cal event could not be found
1081            */
1082            public CalEvent findByG_R_Last(long groupId, boolean repeating,
1083                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
1084                    throws NoSuchEventException;
1085    
1086            /**
1087            * Returns the last cal event in the ordered set where groupId = &#63; and repeating = &#63;.
1088            *
1089            * @param groupId the group ID
1090            * @param repeating the repeating
1091            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1092            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
1093            */
1094            public CalEvent fetchByG_R_Last(long groupId, boolean repeating,
1095                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
1096    
1097            /**
1098            * Returns the cal events before and after the current cal event in the ordered set where groupId = &#63; and repeating = &#63;.
1099            *
1100            * @param eventId the primary key of the current cal event
1101            * @param groupId the group ID
1102            * @param repeating the repeating
1103            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1104            * @return the previous, current, and next cal event
1105            * @throws NoSuchEventException if a cal event with the primary key could not be found
1106            */
1107            public CalEvent[] findByG_R_PrevAndNext(long eventId, long groupId,
1108                    boolean repeating,
1109                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
1110                    throws NoSuchEventException;
1111    
1112            /**
1113            * Removes all the cal events where groupId = &#63; and repeating = &#63; from the database.
1114            *
1115            * @param groupId the group ID
1116            * @param repeating the repeating
1117            */
1118            public void removeByG_R(long groupId, boolean repeating);
1119    
1120            /**
1121            * Returns the number of cal events where groupId = &#63; and repeating = &#63;.
1122            *
1123            * @param groupId the group ID
1124            * @param repeating the repeating
1125            * @return the number of matching cal events
1126            */
1127            public int countByG_R(long groupId, boolean repeating);
1128    
1129            /**
1130            * Returns all the cal events where groupId = &#63; and type = &#63; and repeating = &#63;.
1131            *
1132            * @param groupId the group ID
1133            * @param type the type
1134            * @param repeating the repeating
1135            * @return the matching cal events
1136            */
1137            public java.util.List<CalEvent> findByG_T_R(long groupId,
1138                    java.lang.String type, boolean repeating);
1139    
1140            /**
1141            * Returns a range of all the cal events where groupId = &#63; and type = &#63; and repeating = &#63;.
1142            *
1143            * <p>
1144            * 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 CalEventModelImpl}. 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.
1145            * </p>
1146            *
1147            * @param groupId the group ID
1148            * @param type the type
1149            * @param repeating the repeating
1150            * @param start the lower bound of the range of cal events
1151            * @param end the upper bound of the range of cal events (not inclusive)
1152            * @return the range of matching cal events
1153            */
1154            public java.util.List<CalEvent> findByG_T_R(long groupId,
1155                    java.lang.String type, boolean repeating, int start, int end);
1156    
1157            /**
1158            * Returns an ordered range of all the cal events where groupId = &#63; and type = &#63; and repeating = &#63;.
1159            *
1160            * <p>
1161            * 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 CalEventModelImpl}. 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.
1162            * </p>
1163            *
1164            * @param groupId the group ID
1165            * @param type the type
1166            * @param repeating the repeating
1167            * @param start the lower bound of the range of cal events
1168            * @param end the upper bound of the range of cal events (not inclusive)
1169            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1170            * @return the ordered range of matching cal events
1171            */
1172            public java.util.List<CalEvent> findByG_T_R(long groupId,
1173                    java.lang.String type, boolean repeating, int start, int end,
1174                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
1175    
1176            /**
1177            * Returns an ordered range of all the cal events where groupId = &#63; and type = &#63; and repeating = &#63;.
1178            *
1179            * <p>
1180            * 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 CalEventModelImpl}. 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.
1181            * </p>
1182            *
1183            * @param groupId the group ID
1184            * @param type the type
1185            * @param repeating the repeating
1186            * @param start the lower bound of the range of cal events
1187            * @param end the upper bound of the range of cal events (not inclusive)
1188            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1189            * @param retrieveFromCache whether to retrieve from the finder cache
1190            * @return the ordered range of matching cal events
1191            */
1192            public java.util.List<CalEvent> findByG_T_R(long groupId,
1193                    java.lang.String type, boolean repeating, int start, int end,
1194                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
1195                    boolean retrieveFromCache);
1196    
1197            /**
1198            * Returns the first cal event in the ordered set where groupId = &#63; and type = &#63; and repeating = &#63;.
1199            *
1200            * @param groupId the group ID
1201            * @param type the type
1202            * @param repeating the repeating
1203            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1204            * @return the first matching cal event
1205            * @throws NoSuchEventException if a matching cal event could not be found
1206            */
1207            public CalEvent findByG_T_R_First(long groupId, java.lang.String type,
1208                    boolean repeating,
1209                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
1210                    throws NoSuchEventException;
1211    
1212            /**
1213            * Returns the first cal event in the ordered set where groupId = &#63; and type = &#63; and repeating = &#63;.
1214            *
1215            * @param groupId the group ID
1216            * @param type the type
1217            * @param repeating the repeating
1218            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1219            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
1220            */
1221            public CalEvent fetchByG_T_R_First(long groupId, java.lang.String type,
1222                    boolean repeating,
1223                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
1224    
1225            /**
1226            * Returns the last cal event in the ordered set where groupId = &#63; and type = &#63; and repeating = &#63;.
1227            *
1228            * @param groupId the group ID
1229            * @param type the type
1230            * @param repeating the repeating
1231            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1232            * @return the last matching cal event
1233            * @throws NoSuchEventException if a matching cal event could not be found
1234            */
1235            public CalEvent findByG_T_R_Last(long groupId, java.lang.String type,
1236                    boolean repeating,
1237                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
1238                    throws NoSuchEventException;
1239    
1240            /**
1241            * Returns the last cal event in the ordered set where groupId = &#63; and type = &#63; and repeating = &#63;.
1242            *
1243            * @param groupId the group ID
1244            * @param type the type
1245            * @param repeating the repeating
1246            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1247            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
1248            */
1249            public CalEvent fetchByG_T_R_Last(long groupId, java.lang.String type,
1250                    boolean repeating,
1251                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
1252    
1253            /**
1254            * Returns the cal events before and after the current cal event in the ordered set where groupId = &#63; and type = &#63; and repeating = &#63;.
1255            *
1256            * @param eventId the primary key of the current cal event
1257            * @param groupId the group ID
1258            * @param type the type
1259            * @param repeating the repeating
1260            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1261            * @return the previous, current, and next cal event
1262            * @throws NoSuchEventException if a cal event with the primary key could not be found
1263            */
1264            public CalEvent[] findByG_T_R_PrevAndNext(long eventId, long groupId,
1265                    java.lang.String type, boolean repeating,
1266                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator)
1267                    throws NoSuchEventException;
1268    
1269            /**
1270            * Returns all the cal events where groupId = &#63; and type = any &#63; and repeating = &#63;.
1271            *
1272            * <p>
1273            * 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 CalEventModelImpl}. 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.
1274            * </p>
1275            *
1276            * @param groupId the group ID
1277            * @param types the types
1278            * @param repeating the repeating
1279            * @return the matching cal events
1280            */
1281            public java.util.List<CalEvent> findByG_T_R(long groupId,
1282                    java.lang.String[] types, boolean repeating);
1283    
1284            /**
1285            * Returns a range of all the cal events where groupId = &#63; and type = any &#63; and repeating = &#63;.
1286            *
1287            * <p>
1288            * 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 CalEventModelImpl}. 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.
1289            * </p>
1290            *
1291            * @param groupId the group ID
1292            * @param types the types
1293            * @param repeating the repeating
1294            * @param start the lower bound of the range of cal events
1295            * @param end the upper bound of the range of cal events (not inclusive)
1296            * @return the range of matching cal events
1297            */
1298            public java.util.List<CalEvent> findByG_T_R(long groupId,
1299                    java.lang.String[] types, boolean repeating, int start, int end);
1300    
1301            /**
1302            * Returns an ordered range of all the cal events where groupId = &#63; and type = any &#63; and repeating = &#63;.
1303            *
1304            * <p>
1305            * 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 CalEventModelImpl}. 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.
1306            * </p>
1307            *
1308            * @param groupId the group ID
1309            * @param types the types
1310            * @param repeating the repeating
1311            * @param start the lower bound of the range of cal events
1312            * @param end the upper bound of the range of cal events (not inclusive)
1313            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1314            * @return the ordered range of matching cal events
1315            */
1316            public java.util.List<CalEvent> findByG_T_R(long groupId,
1317                    java.lang.String[] types, boolean repeating, int start, int end,
1318                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
1319    
1320            /**
1321            * Returns an ordered range of all the cal events where groupId = &#63; and type = &#63; and repeating = &#63;, optionally using the finder cache.
1322            *
1323            * <p>
1324            * 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 CalEventModelImpl}. 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.
1325            * </p>
1326            *
1327            * @param groupId the group ID
1328            * @param type the type
1329            * @param repeating the repeating
1330            * @param start the lower bound of the range of cal events
1331            * @param end the upper bound of the range of cal events (not inclusive)
1332            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1333            * @param retrieveFromCache whether to retrieve from the finder cache
1334            * @return the ordered range of matching cal events
1335            */
1336            public java.util.List<CalEvent> findByG_T_R(long groupId,
1337                    java.lang.String[] types, boolean repeating, int start, int end,
1338                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
1339                    boolean retrieveFromCache);
1340    
1341            /**
1342            * Removes all the cal events where groupId = &#63; and type = &#63; and repeating = &#63; from the database.
1343            *
1344            * @param groupId the group ID
1345            * @param type the type
1346            * @param repeating the repeating
1347            */
1348            public void removeByG_T_R(long groupId, java.lang.String type,
1349                    boolean repeating);
1350    
1351            /**
1352            * Returns the number of cal events where groupId = &#63; and type = &#63; and repeating = &#63;.
1353            *
1354            * @param groupId the group ID
1355            * @param type the type
1356            * @param repeating the repeating
1357            * @return the number of matching cal events
1358            */
1359            public int countByG_T_R(long groupId, java.lang.String type,
1360                    boolean repeating);
1361    
1362            /**
1363            * Returns the number of cal events where groupId = &#63; and type = any &#63; and repeating = &#63;.
1364            *
1365            * @param groupId the group ID
1366            * @param types the types
1367            * @param repeating the repeating
1368            * @return the number of matching cal events
1369            */
1370            public int countByG_T_R(long groupId, java.lang.String[] types,
1371                    boolean repeating);
1372    
1373            /**
1374            * Caches the cal event in the entity cache if it is enabled.
1375            *
1376            * @param calEvent the cal event
1377            */
1378            public void cacheResult(CalEvent calEvent);
1379    
1380            /**
1381            * Caches the cal events in the entity cache if it is enabled.
1382            *
1383            * @param calEvents the cal events
1384            */
1385            public void cacheResult(java.util.List<CalEvent> calEvents);
1386    
1387            /**
1388            * Creates a new cal event with the primary key. Does not add the cal event to the database.
1389            *
1390            * @param eventId the primary key for the new cal event
1391            * @return the new cal event
1392            */
1393            public CalEvent create(long eventId);
1394    
1395            /**
1396            * Removes the cal event with the primary key from the database. Also notifies the appropriate model listeners.
1397            *
1398            * @param eventId the primary key of the cal event
1399            * @return the cal event that was removed
1400            * @throws NoSuchEventException if a cal event with the primary key could not be found
1401            */
1402            public CalEvent remove(long eventId) throws NoSuchEventException;
1403    
1404            public CalEvent updateImpl(CalEvent calEvent);
1405    
1406            /**
1407            * Returns the cal event with the primary key or throws a {@link NoSuchEventException} if it could not be found.
1408            *
1409            * @param eventId the primary key of the cal event
1410            * @return the cal event
1411            * @throws NoSuchEventException if a cal event with the primary key could not be found
1412            */
1413            public CalEvent findByPrimaryKey(long eventId) throws NoSuchEventException;
1414    
1415            /**
1416            * Returns the cal event with the primary key or returns <code>null</code> if it could not be found.
1417            *
1418            * @param eventId the primary key of the cal event
1419            * @return the cal event, or <code>null</code> if a cal event with the primary key could not be found
1420            */
1421            public CalEvent fetchByPrimaryKey(long eventId);
1422    
1423            @Override
1424            public java.util.Map<java.io.Serializable, CalEvent> fetchByPrimaryKeys(
1425                    java.util.Set<java.io.Serializable> primaryKeys);
1426    
1427            /**
1428            * Returns all the cal events.
1429            *
1430            * @return the cal events
1431            */
1432            public java.util.List<CalEvent> findAll();
1433    
1434            /**
1435            * Returns a range of all the cal events.
1436            *
1437            * <p>
1438            * 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 CalEventModelImpl}. 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.
1439            * </p>
1440            *
1441            * @param start the lower bound of the range of cal events
1442            * @param end the upper bound of the range of cal events (not inclusive)
1443            * @return the range of cal events
1444            */
1445            public java.util.List<CalEvent> findAll(int start, int end);
1446    
1447            /**
1448            * Returns an ordered range of all the cal events.
1449            *
1450            * <p>
1451            * 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 CalEventModelImpl}. 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.
1452            * </p>
1453            *
1454            * @param start the lower bound of the range of cal events
1455            * @param end the upper bound of the range of cal events (not inclusive)
1456            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1457            * @return the ordered range of cal events
1458            */
1459            public java.util.List<CalEvent> findAll(int start, int end,
1460                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator);
1461    
1462            /**
1463            * Returns an ordered range of all the cal events.
1464            *
1465            * <p>
1466            * 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 CalEventModelImpl}. 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.
1467            * </p>
1468            *
1469            * @param start the lower bound of the range of cal events
1470            * @param end the upper bound of the range of cal events (not inclusive)
1471            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1472            * @param retrieveFromCache whether to retrieve from the finder cache
1473            * @return the ordered range of cal events
1474            */
1475            public java.util.List<CalEvent> findAll(int start, int end,
1476                    com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator,
1477                    boolean retrieveFromCache);
1478    
1479            /**
1480            * Removes all the cal events from the database.
1481            */
1482            public void removeAll();
1483    
1484            /**
1485            * Returns the number of cal events.
1486            *
1487            * @return the number of cal events
1488            */
1489            public int countAll();
1490    
1491            @Override
1492            public java.util.Set<java.lang.String> getBadColumnNames();
1493    }