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