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