001    /**
002     * Copyright (c) 2000-2012 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 com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.calendar.model.CalEvent;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the cal event service. This utility wraps {@link CalEventPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see CalEventPersistence
037     * @see CalEventPersistenceImpl
038     * @generated
039     */
040    public class CalEventUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(CalEvent calEvent) {
058                    getPersistence().clearCache(calEvent);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<CalEvent> findWithDynamicQuery(DynamicQuery dynamicQuery)
073                    throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<CalEvent> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<CalEvent> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static CalEvent update(CalEvent calEvent) throws SystemException {
101                    return getPersistence().update(calEvent);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static CalEvent update(CalEvent calEvent,
108                    ServiceContext serviceContext) throws SystemException {
109                    return getPersistence().update(calEvent, serviceContext);
110            }
111    
112            /**
113            * Caches the cal event in the entity cache if it is enabled.
114            *
115            * @param calEvent the cal event
116            */
117            public static void cacheResult(
118                    com.liferay.portlet.calendar.model.CalEvent calEvent) {
119                    getPersistence().cacheResult(calEvent);
120            }
121    
122            /**
123            * Caches the cal events in the entity cache if it is enabled.
124            *
125            * @param calEvents the cal events
126            */
127            public static void cacheResult(
128                    java.util.List<com.liferay.portlet.calendar.model.CalEvent> calEvents) {
129                    getPersistence().cacheResult(calEvents);
130            }
131    
132            /**
133            * Creates a new cal event with the primary key. Does not add the cal event to the database.
134            *
135            * @param eventId the primary key for the new cal event
136            * @return the new cal event
137            */
138            public static com.liferay.portlet.calendar.model.CalEvent create(
139                    long eventId) {
140                    return getPersistence().create(eventId);
141            }
142    
143            /**
144            * Removes the cal event with the primary key from the database. Also notifies the appropriate model listeners.
145            *
146            * @param eventId the primary key of the cal event
147            * @return the cal event that was removed
148            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
149            * @throws SystemException if a system exception occurred
150            */
151            public static com.liferay.portlet.calendar.model.CalEvent remove(
152                    long eventId)
153                    throws com.liferay.portal.kernel.exception.SystemException,
154                            com.liferay.portlet.calendar.NoSuchEventException {
155                    return getPersistence().remove(eventId);
156            }
157    
158            public static com.liferay.portlet.calendar.model.CalEvent updateImpl(
159                    com.liferay.portlet.calendar.model.CalEvent calEvent)
160                    throws com.liferay.portal.kernel.exception.SystemException {
161                    return getPersistence().updateImpl(calEvent);
162            }
163    
164            /**
165            * Returns the cal event with the primary key or throws a {@link com.liferay.portlet.calendar.NoSuchEventException} if it could not be found.
166            *
167            * @param eventId the primary key of the cal event
168            * @return the cal event
169            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
170            * @throws SystemException if a system exception occurred
171            */
172            public static com.liferay.portlet.calendar.model.CalEvent findByPrimaryKey(
173                    long eventId)
174                    throws com.liferay.portal.kernel.exception.SystemException,
175                            com.liferay.portlet.calendar.NoSuchEventException {
176                    return getPersistence().findByPrimaryKey(eventId);
177            }
178    
179            /**
180            * Returns the cal event with the primary key or returns <code>null</code> if it could not be found.
181            *
182            * @param eventId the primary key of the cal event
183            * @return the cal event, or <code>null</code> if a cal event with the primary key could not be found
184            * @throws SystemException if a system exception occurred
185            */
186            public static com.liferay.portlet.calendar.model.CalEvent fetchByPrimaryKey(
187                    long eventId)
188                    throws com.liferay.portal.kernel.exception.SystemException {
189                    return getPersistence().fetchByPrimaryKey(eventId);
190            }
191    
192            /**
193            * Returns all the cal events where uuid = &#63;.
194            *
195            * @param uuid the uuid
196            * @return the matching cal events
197            * @throws SystemException if a system exception occurred
198            */
199            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByUuid(
200                    java.lang.String uuid)
201                    throws com.liferay.portal.kernel.exception.SystemException {
202                    return getPersistence().findByUuid(uuid);
203            }
204    
205            /**
206            * Returns a range of all the cal events where uuid = &#63;.
207            *
208            * <p>
209            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
210            * </p>
211            *
212            * @param uuid the uuid
213            * @param start the lower bound of the range of cal events
214            * @param end the upper bound of the range of cal events (not inclusive)
215            * @return the range of matching cal events
216            * @throws SystemException if a system exception occurred
217            */
218            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByUuid(
219                    java.lang.String uuid, int start, int end)
220                    throws com.liferay.portal.kernel.exception.SystemException {
221                    return getPersistence().findByUuid(uuid, start, end);
222            }
223    
224            /**
225            * Returns an ordered range of all the cal events where uuid = &#63;.
226            *
227            * <p>
228            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
229            * </p>
230            *
231            * @param uuid the uuid
232            * @param start the lower bound of the range of cal events
233            * @param end the upper bound of the range of cal events (not inclusive)
234            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
235            * @return the ordered range of matching cal events
236            * @throws SystemException if a system exception occurred
237            */
238            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByUuid(
239                    java.lang.String uuid, int start, int end,
240                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
241                    throws com.liferay.portal.kernel.exception.SystemException {
242                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
243            }
244    
245            /**
246            * Returns the first cal event in the ordered set where uuid = &#63;.
247            *
248            * @param uuid the uuid
249            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
250            * @return the first matching cal event
251            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
252            * @throws SystemException if a system exception occurred
253            */
254            public static com.liferay.portlet.calendar.model.CalEvent findByUuid_First(
255                    java.lang.String uuid,
256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
257                    throws com.liferay.portal.kernel.exception.SystemException,
258                            com.liferay.portlet.calendar.NoSuchEventException {
259                    return getPersistence().findByUuid_First(uuid, orderByComparator);
260            }
261    
262            /**
263            * Returns the first cal event in the ordered set where uuid = &#63;.
264            *
265            * @param uuid the uuid
266            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
267            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
268            * @throws SystemException if a system exception occurred
269            */
270            public static com.liferay.portlet.calendar.model.CalEvent fetchByUuid_First(
271                    java.lang.String uuid,
272                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
273                    throws com.liferay.portal.kernel.exception.SystemException {
274                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
275            }
276    
277            /**
278            * Returns the last cal event in the ordered set where uuid = &#63;.
279            *
280            * @param uuid the uuid
281            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
282            * @return the last matching cal event
283            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
284            * @throws SystemException if a system exception occurred
285            */
286            public static com.liferay.portlet.calendar.model.CalEvent findByUuid_Last(
287                    java.lang.String uuid,
288                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
289                    throws com.liferay.portal.kernel.exception.SystemException,
290                            com.liferay.portlet.calendar.NoSuchEventException {
291                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
292            }
293    
294            /**
295            * Returns the last cal event in the ordered set where uuid = &#63;.
296            *
297            * @param uuid the uuid
298            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
299            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
300            * @throws SystemException if a system exception occurred
301            */
302            public static com.liferay.portlet.calendar.model.CalEvent fetchByUuid_Last(
303                    java.lang.String uuid,
304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
305                    throws com.liferay.portal.kernel.exception.SystemException {
306                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
307            }
308    
309            /**
310            * Returns the cal events before and after the current cal event in the ordered set where uuid = &#63;.
311            *
312            * @param eventId the primary key of the current cal event
313            * @param uuid the uuid
314            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
315            * @return the previous, current, and next cal event
316            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
317            * @throws SystemException if a system exception occurred
318            */
319            public static com.liferay.portlet.calendar.model.CalEvent[] findByUuid_PrevAndNext(
320                    long eventId, java.lang.String uuid,
321                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
322                    throws com.liferay.portal.kernel.exception.SystemException,
323                            com.liferay.portlet.calendar.NoSuchEventException {
324                    return getPersistence()
325                                       .findByUuid_PrevAndNext(eventId, uuid, orderByComparator);
326            }
327    
328            /**
329            * Returns the cal event where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.calendar.NoSuchEventException} if it could not be found.
330            *
331            * @param uuid the uuid
332            * @param groupId the group ID
333            * @return the matching cal event
334            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
335            * @throws SystemException if a system exception occurred
336            */
337            public static com.liferay.portlet.calendar.model.CalEvent findByUUID_G(
338                    java.lang.String uuid, long groupId)
339                    throws com.liferay.portal.kernel.exception.SystemException,
340                            com.liferay.portlet.calendar.NoSuchEventException {
341                    return getPersistence().findByUUID_G(uuid, groupId);
342            }
343    
344            /**
345            * 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.
346            *
347            * @param uuid the uuid
348            * @param groupId the group ID
349            * @return the matching cal event, or <code>null</code> if a matching cal event could not be found
350            * @throws SystemException if a system exception occurred
351            */
352            public static com.liferay.portlet.calendar.model.CalEvent fetchByUUID_G(
353                    java.lang.String uuid, long groupId)
354                    throws com.liferay.portal.kernel.exception.SystemException {
355                    return getPersistence().fetchByUUID_G(uuid, groupId);
356            }
357    
358            /**
359            * 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.
360            *
361            * @param uuid the uuid
362            * @param groupId the group ID
363            * @param retrieveFromCache whether to use the finder cache
364            * @return the matching cal event, or <code>null</code> if a matching cal event could not be found
365            * @throws SystemException if a system exception occurred
366            */
367            public static com.liferay.portlet.calendar.model.CalEvent fetchByUUID_G(
368                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
369                    throws com.liferay.portal.kernel.exception.SystemException {
370                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
371            }
372    
373            /**
374            * Returns all the cal events where uuid = &#63; and companyId = &#63;.
375            *
376            * @param uuid the uuid
377            * @param companyId the company ID
378            * @return the matching cal events
379            * @throws SystemException if a system exception occurred
380            */
381            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByUuid_C(
382                    java.lang.String uuid, long companyId)
383                    throws com.liferay.portal.kernel.exception.SystemException {
384                    return getPersistence().findByUuid_C(uuid, companyId);
385            }
386    
387            /**
388            * Returns a range of all the cal events where uuid = &#63; and companyId = &#63;.
389            *
390            * <p>
391            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
392            * </p>
393            *
394            * @param uuid the uuid
395            * @param companyId the company ID
396            * @param start the lower bound of the range of cal events
397            * @param end the upper bound of the range of cal events (not inclusive)
398            * @return the range of matching cal events
399            * @throws SystemException if a system exception occurred
400            */
401            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByUuid_C(
402                    java.lang.String uuid, long companyId, int start, int end)
403                    throws com.liferay.portal.kernel.exception.SystemException {
404                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
405            }
406    
407            /**
408            * Returns an ordered range of all the cal events where uuid = &#63; and companyId = &#63;.
409            *
410            * <p>
411            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
412            * </p>
413            *
414            * @param uuid the uuid
415            * @param companyId the company ID
416            * @param start the lower bound of the range of cal events
417            * @param end the upper bound of the range of cal events (not inclusive)
418            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
419            * @return the ordered range of matching cal events
420            * @throws SystemException if a system exception occurred
421            */
422            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByUuid_C(
423                    java.lang.String uuid, long companyId, int start, int end,
424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
425                    throws com.liferay.portal.kernel.exception.SystemException {
426                    return getPersistence()
427                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
428            }
429    
430            /**
431            * Returns the first cal event in the ordered set where uuid = &#63; and companyId = &#63;.
432            *
433            * @param uuid the uuid
434            * @param companyId the company ID
435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
436            * @return the first matching cal event
437            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
438            * @throws SystemException if a system exception occurred
439            */
440            public static com.liferay.portlet.calendar.model.CalEvent findByUuid_C_First(
441                    java.lang.String uuid, long companyId,
442                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
443                    throws com.liferay.portal.kernel.exception.SystemException,
444                            com.liferay.portlet.calendar.NoSuchEventException {
445                    return getPersistence()
446                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
447            }
448    
449            /**
450            * Returns the first cal event in the ordered set where uuid = &#63; and companyId = &#63;.
451            *
452            * @param uuid the uuid
453            * @param companyId the company ID
454            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
455            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
456            * @throws SystemException if a system exception occurred
457            */
458            public static com.liferay.portlet.calendar.model.CalEvent fetchByUuid_C_First(
459                    java.lang.String uuid, long companyId,
460                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
461                    throws com.liferay.portal.kernel.exception.SystemException {
462                    return getPersistence()
463                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
464            }
465    
466            /**
467            * Returns the last cal event in the ordered set where uuid = &#63; and companyId = &#63;.
468            *
469            * @param uuid the uuid
470            * @param companyId the company ID
471            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
472            * @return the last matching cal event
473            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
474            * @throws SystemException if a system exception occurred
475            */
476            public static com.liferay.portlet.calendar.model.CalEvent findByUuid_C_Last(
477                    java.lang.String uuid, long companyId,
478                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
479                    throws com.liferay.portal.kernel.exception.SystemException,
480                            com.liferay.portlet.calendar.NoSuchEventException {
481                    return getPersistence()
482                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
483            }
484    
485            /**
486            * Returns the last cal event in the ordered set where uuid = &#63; and companyId = &#63;.
487            *
488            * @param uuid the uuid
489            * @param companyId the company ID
490            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
491            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
492            * @throws SystemException if a system exception occurred
493            */
494            public static com.liferay.portlet.calendar.model.CalEvent fetchByUuid_C_Last(
495                    java.lang.String uuid, long companyId,
496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
497                    throws com.liferay.portal.kernel.exception.SystemException {
498                    return getPersistence()
499                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
500            }
501    
502            /**
503            * Returns the cal events before and after the current cal event in the ordered set where uuid = &#63; and companyId = &#63;.
504            *
505            * @param eventId the primary key of the current cal event
506            * @param uuid the uuid
507            * @param companyId the company ID
508            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
509            * @return the previous, current, and next cal event
510            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
511            * @throws SystemException if a system exception occurred
512            */
513            public static com.liferay.portlet.calendar.model.CalEvent[] findByUuid_C_PrevAndNext(
514                    long eventId, java.lang.String uuid, long companyId,
515                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
516                    throws com.liferay.portal.kernel.exception.SystemException,
517                            com.liferay.portlet.calendar.NoSuchEventException {
518                    return getPersistence()
519                                       .findByUuid_C_PrevAndNext(eventId, uuid, companyId,
520                            orderByComparator);
521            }
522    
523            /**
524            * Returns all the cal events where companyId = &#63;.
525            *
526            * @param companyId the company ID
527            * @return the matching cal events
528            * @throws SystemException if a system exception occurred
529            */
530            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByCompanyId(
531                    long companyId)
532                    throws com.liferay.portal.kernel.exception.SystemException {
533                    return getPersistence().findByCompanyId(companyId);
534            }
535    
536            /**
537            * Returns a range of all the cal events where companyId = &#63;.
538            *
539            * <p>
540            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
541            * </p>
542            *
543            * @param companyId the company ID
544            * @param start the lower bound of the range of cal events
545            * @param end the upper bound of the range of cal events (not inclusive)
546            * @return the range of matching cal events
547            * @throws SystemException if a system exception occurred
548            */
549            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByCompanyId(
550                    long companyId, int start, int end)
551                    throws com.liferay.portal.kernel.exception.SystemException {
552                    return getPersistence().findByCompanyId(companyId, start, end);
553            }
554    
555            /**
556            * Returns an ordered range of all the cal events where companyId = &#63;.
557            *
558            * <p>
559            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
560            * </p>
561            *
562            * @param companyId the company ID
563            * @param start the lower bound of the range of cal events
564            * @param end the upper bound of the range of cal events (not inclusive)
565            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
566            * @return the ordered range of matching cal events
567            * @throws SystemException if a system exception occurred
568            */
569            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByCompanyId(
570                    long companyId, int start, int end,
571                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
572                    throws com.liferay.portal.kernel.exception.SystemException {
573                    return getPersistence()
574                                       .findByCompanyId(companyId, start, end, orderByComparator);
575            }
576    
577            /**
578            * Returns the first cal event in the ordered set where companyId = &#63;.
579            *
580            * @param companyId the company ID
581            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
582            * @return the first matching cal event
583            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
584            * @throws SystemException if a system exception occurred
585            */
586            public static com.liferay.portlet.calendar.model.CalEvent findByCompanyId_First(
587                    long companyId,
588                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
589                    throws com.liferay.portal.kernel.exception.SystemException,
590                            com.liferay.portlet.calendar.NoSuchEventException {
591                    return getPersistence()
592                                       .findByCompanyId_First(companyId, orderByComparator);
593            }
594    
595            /**
596            * Returns the first 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 first matching cal event, or <code>null</code> if a matching cal event could not be found
601            * @throws SystemException if a system exception occurred
602            */
603            public static com.liferay.portlet.calendar.model.CalEvent fetchByCompanyId_First(
604                    long companyId,
605                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
606                    throws com.liferay.portal.kernel.exception.SystemException {
607                    return getPersistence()
608                                       .fetchByCompanyId_First(companyId, orderByComparator);
609            }
610    
611            /**
612            * Returns the last cal event in the ordered set where companyId = &#63;.
613            *
614            * @param companyId the company ID
615            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
616            * @return the last matching cal event
617            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
618            * @throws SystemException if a system exception occurred
619            */
620            public static com.liferay.portlet.calendar.model.CalEvent findByCompanyId_Last(
621                    long companyId,
622                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
623                    throws com.liferay.portal.kernel.exception.SystemException,
624                            com.liferay.portlet.calendar.NoSuchEventException {
625                    return getPersistence()
626                                       .findByCompanyId_Last(companyId, orderByComparator);
627            }
628    
629            /**
630            * Returns the last cal event in the ordered set where companyId = &#63;.
631            *
632            * @param companyId the company ID
633            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
634            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
635            * @throws SystemException if a system exception occurred
636            */
637            public static com.liferay.portlet.calendar.model.CalEvent fetchByCompanyId_Last(
638                    long companyId,
639                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
640                    throws com.liferay.portal.kernel.exception.SystemException {
641                    return getPersistence()
642                                       .fetchByCompanyId_Last(companyId, orderByComparator);
643            }
644    
645            /**
646            * Returns the cal events before and after the current cal event in the ordered set where companyId = &#63;.
647            *
648            * @param eventId the primary key of the current cal event
649            * @param companyId the company ID
650            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
651            * @return the previous, current, and next cal event
652            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
653            * @throws SystemException if a system exception occurred
654            */
655            public static com.liferay.portlet.calendar.model.CalEvent[] findByCompanyId_PrevAndNext(
656                    long eventId, long companyId,
657                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
658                    throws com.liferay.portal.kernel.exception.SystemException,
659                            com.liferay.portlet.calendar.NoSuchEventException {
660                    return getPersistence()
661                                       .findByCompanyId_PrevAndNext(eventId, companyId,
662                            orderByComparator);
663            }
664    
665            /**
666            * Returns all the cal events where groupId = &#63;.
667            *
668            * @param groupId the group ID
669            * @return the matching cal events
670            * @throws SystemException if a system exception occurred
671            */
672            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByGroupId(
673                    long groupId)
674                    throws com.liferay.portal.kernel.exception.SystemException {
675                    return getPersistence().findByGroupId(groupId);
676            }
677    
678            /**
679            * Returns a range of all the cal events where groupId = &#63;.
680            *
681            * <p>
682            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
683            * </p>
684            *
685            * @param groupId the group ID
686            * @param start the lower bound of the range of cal events
687            * @param end the upper bound of the range of cal events (not inclusive)
688            * @return the range of matching cal events
689            * @throws SystemException if a system exception occurred
690            */
691            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByGroupId(
692                    long groupId, int start, int end)
693                    throws com.liferay.portal.kernel.exception.SystemException {
694                    return getPersistence().findByGroupId(groupId, start, end);
695            }
696    
697            /**
698            * Returns an ordered range of all the cal events where groupId = &#63;.
699            *
700            * <p>
701            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
702            * </p>
703            *
704            * @param groupId the group ID
705            * @param start the lower bound of the range of cal events
706            * @param end the upper bound of the range of cal events (not inclusive)
707            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
708            * @return the ordered range of matching cal events
709            * @throws SystemException if a system exception occurred
710            */
711            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByGroupId(
712                    long groupId, int start, int end,
713                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
714                    throws com.liferay.portal.kernel.exception.SystemException {
715                    return getPersistence()
716                                       .findByGroupId(groupId, start, end, orderByComparator);
717            }
718    
719            /**
720            * Returns the first cal event in the ordered set where groupId = &#63;.
721            *
722            * @param groupId the group ID
723            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
724            * @return the first matching cal event
725            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
726            * @throws SystemException if a system exception occurred
727            */
728            public static com.liferay.portlet.calendar.model.CalEvent findByGroupId_First(
729                    long groupId,
730                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
731                    throws com.liferay.portal.kernel.exception.SystemException,
732                            com.liferay.portlet.calendar.NoSuchEventException {
733                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
734            }
735    
736            /**
737            * Returns the first cal event in the ordered set where groupId = &#63;.
738            *
739            * @param groupId the group ID
740            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
741            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
742            * @throws SystemException if a system exception occurred
743            */
744            public static com.liferay.portlet.calendar.model.CalEvent fetchByGroupId_First(
745                    long groupId,
746                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
747                    throws com.liferay.portal.kernel.exception.SystemException {
748                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
749            }
750    
751            /**
752            * Returns the last cal event in the ordered set where groupId = &#63;.
753            *
754            * @param groupId the group ID
755            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
756            * @return the last matching cal event
757            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
758            * @throws SystemException if a system exception occurred
759            */
760            public static com.liferay.portlet.calendar.model.CalEvent findByGroupId_Last(
761                    long groupId,
762                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
763                    throws com.liferay.portal.kernel.exception.SystemException,
764                            com.liferay.portlet.calendar.NoSuchEventException {
765                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
766            }
767    
768            /**
769            * Returns the last cal event in the ordered set where groupId = &#63;.
770            *
771            * @param groupId the group ID
772            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
773            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
774            * @throws SystemException if a system exception occurred
775            */
776            public static com.liferay.portlet.calendar.model.CalEvent fetchByGroupId_Last(
777                    long groupId,
778                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
779                    throws com.liferay.portal.kernel.exception.SystemException {
780                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
781            }
782    
783            /**
784            * Returns the cal events before and after the current cal event in the ordered set where groupId = &#63;.
785            *
786            * @param eventId the primary key of the current cal event
787            * @param groupId the group ID
788            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
789            * @return the previous, current, and next cal event
790            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
791            * @throws SystemException if a system exception occurred
792            */
793            public static com.liferay.portlet.calendar.model.CalEvent[] findByGroupId_PrevAndNext(
794                    long eventId, long groupId,
795                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
796                    throws com.liferay.portal.kernel.exception.SystemException,
797                            com.liferay.portlet.calendar.NoSuchEventException {
798                    return getPersistence()
799                                       .findByGroupId_PrevAndNext(eventId, groupId,
800                            orderByComparator);
801            }
802    
803            /**
804            * Returns all the cal events that the user has permission to view where groupId = &#63;.
805            *
806            * @param groupId the group ID
807            * @return the matching cal events that the user has permission to view
808            * @throws SystemException if a system exception occurred
809            */
810            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByGroupId(
811                    long groupId)
812                    throws com.liferay.portal.kernel.exception.SystemException {
813                    return getPersistence().filterFindByGroupId(groupId);
814            }
815    
816            /**
817            * Returns a range of all the cal events that the user has permission to view where groupId = &#63;.
818            *
819            * <p>
820            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
821            * </p>
822            *
823            * @param groupId the group ID
824            * @param start the lower bound of the range of cal events
825            * @param end the upper bound of the range of cal events (not inclusive)
826            * @return the range of matching cal events that the user has permission to view
827            * @throws SystemException if a system exception occurred
828            */
829            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByGroupId(
830                    long groupId, int start, int end)
831                    throws com.liferay.portal.kernel.exception.SystemException {
832                    return getPersistence().filterFindByGroupId(groupId, start, end);
833            }
834    
835            /**
836            * Returns an ordered range of all the cal events that the user has permissions to view where groupId = &#63;.
837            *
838            * <p>
839            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
840            * </p>
841            *
842            * @param groupId the group ID
843            * @param start the lower bound of the range of cal events
844            * @param end the upper bound of the range of cal events (not inclusive)
845            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
846            * @return the ordered range of matching cal events that the user has permission to view
847            * @throws SystemException if a system exception occurred
848            */
849            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByGroupId(
850                    long groupId, int start, int end,
851                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
852                    throws com.liferay.portal.kernel.exception.SystemException {
853                    return getPersistence()
854                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
855            }
856    
857            /**
858            * Returns the cal events before and after the current cal event in the ordered set of cal events that the user has permission to view where groupId = &#63;.
859            *
860            * @param eventId the primary key of the current cal event
861            * @param groupId the group ID
862            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
863            * @return the previous, current, and next cal event
864            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
865            * @throws SystemException if a system exception occurred
866            */
867            public static com.liferay.portlet.calendar.model.CalEvent[] filterFindByGroupId_PrevAndNext(
868                    long eventId, long groupId,
869                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
870                    throws com.liferay.portal.kernel.exception.SystemException,
871                            com.liferay.portlet.calendar.NoSuchEventException {
872                    return getPersistence()
873                                       .filterFindByGroupId_PrevAndNext(eventId, groupId,
874                            orderByComparator);
875            }
876    
877            /**
878            * Returns all the cal events where remindBy &ne; &#63;.
879            *
880            * @param remindBy the remind by
881            * @return the matching cal events
882            * @throws SystemException if a system exception occurred
883            */
884            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByNotRemindBy(
885                    int remindBy)
886                    throws com.liferay.portal.kernel.exception.SystemException {
887                    return getPersistence().findByNotRemindBy(remindBy);
888            }
889    
890            /**
891            * Returns a range of all the cal events where remindBy &ne; &#63;.
892            *
893            * <p>
894            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
895            * </p>
896            *
897            * @param remindBy the remind by
898            * @param start the lower bound of the range of cal events
899            * @param end the upper bound of the range of cal events (not inclusive)
900            * @return the range of matching cal events
901            * @throws SystemException if a system exception occurred
902            */
903            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByNotRemindBy(
904                    int remindBy, int start, int end)
905                    throws com.liferay.portal.kernel.exception.SystemException {
906                    return getPersistence().findByNotRemindBy(remindBy, start, end);
907            }
908    
909            /**
910            * Returns an ordered range of all the cal events where remindBy &ne; &#63;.
911            *
912            * <p>
913            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
914            * </p>
915            *
916            * @param remindBy the remind by
917            * @param start the lower bound of the range of cal events
918            * @param end the upper bound of the range of cal events (not inclusive)
919            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
920            * @return the ordered range of matching cal events
921            * @throws SystemException if a system exception occurred
922            */
923            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByNotRemindBy(
924                    int remindBy, int start, int end,
925                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
926                    throws com.liferay.portal.kernel.exception.SystemException {
927                    return getPersistence()
928                                       .findByNotRemindBy(remindBy, start, end, orderByComparator);
929            }
930    
931            /**
932            * Returns the first cal event in the ordered set where remindBy &ne; &#63;.
933            *
934            * @param remindBy the remind by
935            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
936            * @return the first matching cal event
937            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
938            * @throws SystemException if a system exception occurred
939            */
940            public static com.liferay.portlet.calendar.model.CalEvent findByNotRemindBy_First(
941                    int remindBy,
942                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
943                    throws com.liferay.portal.kernel.exception.SystemException,
944                            com.liferay.portlet.calendar.NoSuchEventException {
945                    return getPersistence()
946                                       .findByNotRemindBy_First(remindBy, orderByComparator);
947            }
948    
949            /**
950            * Returns the first cal event in the ordered set where remindBy &ne; &#63;.
951            *
952            * @param remindBy the remind by
953            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
954            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
955            * @throws SystemException if a system exception occurred
956            */
957            public static com.liferay.portlet.calendar.model.CalEvent fetchByNotRemindBy_First(
958                    int remindBy,
959                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
960                    throws com.liferay.portal.kernel.exception.SystemException {
961                    return getPersistence()
962                                       .fetchByNotRemindBy_First(remindBy, orderByComparator);
963            }
964    
965            /**
966            * Returns the last cal event in the ordered set where remindBy &ne; &#63;.
967            *
968            * @param remindBy the remind by
969            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
970            * @return the last matching cal event
971            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
972            * @throws SystemException if a system exception occurred
973            */
974            public static com.liferay.portlet.calendar.model.CalEvent findByNotRemindBy_Last(
975                    int remindBy,
976                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
977                    throws com.liferay.portal.kernel.exception.SystemException,
978                            com.liferay.portlet.calendar.NoSuchEventException {
979                    return getPersistence()
980                                       .findByNotRemindBy_Last(remindBy, orderByComparator);
981            }
982    
983            /**
984            * Returns the last cal event in the ordered set where remindBy &ne; &#63;.
985            *
986            * @param remindBy the remind by
987            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
988            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
989            * @throws SystemException if a system exception occurred
990            */
991            public static com.liferay.portlet.calendar.model.CalEvent fetchByNotRemindBy_Last(
992                    int remindBy,
993                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
994                    throws com.liferay.portal.kernel.exception.SystemException {
995                    return getPersistence()
996                                       .fetchByNotRemindBy_Last(remindBy, orderByComparator);
997            }
998    
999            /**
1000            * Returns the cal events before and after the current cal event in the ordered set where remindBy &ne; &#63;.
1001            *
1002            * @param eventId the primary key of the current cal event
1003            * @param remindBy the remind by
1004            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1005            * @return the previous, current, and next cal event
1006            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
1007            * @throws SystemException if a system exception occurred
1008            */
1009            public static com.liferay.portlet.calendar.model.CalEvent[] findByNotRemindBy_PrevAndNext(
1010                    long eventId, int remindBy,
1011                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1012                    throws com.liferay.portal.kernel.exception.SystemException,
1013                            com.liferay.portlet.calendar.NoSuchEventException {
1014                    return getPersistence()
1015                                       .findByNotRemindBy_PrevAndNext(eventId, remindBy,
1016                            orderByComparator);
1017            }
1018    
1019            /**
1020            * Returns all the cal events where groupId = &#63; and type = &#63;.
1021            *
1022            * @param groupId the group ID
1023            * @param type the type
1024            * @return the matching cal events
1025            * @throws SystemException if a system exception occurred
1026            */
1027            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T(
1028                    long groupId, java.lang.String type)
1029                    throws com.liferay.portal.kernel.exception.SystemException {
1030                    return getPersistence().findByG_T(groupId, type);
1031            }
1032    
1033            /**
1034            * Returns a range of all the cal events where groupId = &#63; and type = &#63;.
1035            *
1036            * <p>
1037            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1038            * </p>
1039            *
1040            * @param groupId the group ID
1041            * @param type the type
1042            * @param start the lower bound of the range of cal events
1043            * @param end the upper bound of the range of cal events (not inclusive)
1044            * @return the range of matching cal events
1045            * @throws SystemException if a system exception occurred
1046            */
1047            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T(
1048                    long groupId, java.lang.String type, int start, int end)
1049                    throws com.liferay.portal.kernel.exception.SystemException {
1050                    return getPersistence().findByG_T(groupId, type, start, end);
1051            }
1052    
1053            /**
1054            * Returns an ordered range of all the cal events where groupId = &#63; and type = &#63;.
1055            *
1056            * <p>
1057            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1058            * </p>
1059            *
1060            * @param groupId the group ID
1061            * @param type the type
1062            * @param start the lower bound of the range of cal events
1063            * @param end the upper bound of the range of cal events (not inclusive)
1064            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1065            * @return the ordered range of matching cal events
1066            * @throws SystemException if a system exception occurred
1067            */
1068            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T(
1069                    long groupId, java.lang.String type, int start, int end,
1070                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1071                    throws com.liferay.portal.kernel.exception.SystemException {
1072                    return getPersistence()
1073                                       .findByG_T(groupId, type, start, end, orderByComparator);
1074            }
1075    
1076            /**
1077            * Returns the first cal event in the ordered set where groupId = &#63; and type = &#63;.
1078            *
1079            * @param groupId the group ID
1080            * @param type the type
1081            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1082            * @return the first matching cal event
1083            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
1084            * @throws SystemException if a system exception occurred
1085            */
1086            public static com.liferay.portlet.calendar.model.CalEvent findByG_T_First(
1087                    long groupId, java.lang.String type,
1088                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1089                    throws com.liferay.portal.kernel.exception.SystemException,
1090                            com.liferay.portlet.calendar.NoSuchEventException {
1091                    return getPersistence().findByG_T_First(groupId, type, orderByComparator);
1092            }
1093    
1094            /**
1095            * Returns the first cal event in the ordered set where groupId = &#63; and type = &#63;.
1096            *
1097            * @param groupId the group ID
1098            * @param type the type
1099            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1100            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
1101            * @throws SystemException if a system exception occurred
1102            */
1103            public static com.liferay.portlet.calendar.model.CalEvent fetchByG_T_First(
1104                    long groupId, java.lang.String type,
1105                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1106                    throws com.liferay.portal.kernel.exception.SystemException {
1107                    return getPersistence()
1108                                       .fetchByG_T_First(groupId, type, orderByComparator);
1109            }
1110    
1111            /**
1112            * Returns the last cal event in the ordered set where groupId = &#63; and type = &#63;.
1113            *
1114            * @param groupId the group ID
1115            * @param type the type
1116            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1117            * @return the last matching cal event
1118            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
1119            * @throws SystemException if a system exception occurred
1120            */
1121            public static com.liferay.portlet.calendar.model.CalEvent findByG_T_Last(
1122                    long groupId, java.lang.String type,
1123                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1124                    throws com.liferay.portal.kernel.exception.SystemException,
1125                            com.liferay.portlet.calendar.NoSuchEventException {
1126                    return getPersistence().findByG_T_Last(groupId, type, orderByComparator);
1127            }
1128    
1129            /**
1130            * Returns the last cal event in the ordered set where groupId = &#63; and type = &#63;.
1131            *
1132            * @param groupId the group ID
1133            * @param type the type
1134            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1135            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
1136            * @throws SystemException if a system exception occurred
1137            */
1138            public static com.liferay.portlet.calendar.model.CalEvent fetchByG_T_Last(
1139                    long groupId, java.lang.String type,
1140                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1141                    throws com.liferay.portal.kernel.exception.SystemException {
1142                    return getPersistence().fetchByG_T_Last(groupId, type, orderByComparator);
1143            }
1144    
1145            /**
1146            * Returns the cal events before and after the current cal event in the ordered set where groupId = &#63; and type = &#63;.
1147            *
1148            * @param eventId the primary key of the current cal event
1149            * @param groupId the group ID
1150            * @param type the type
1151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1152            * @return the previous, current, and next cal event
1153            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
1154            * @throws SystemException if a system exception occurred
1155            */
1156            public static com.liferay.portlet.calendar.model.CalEvent[] findByG_T_PrevAndNext(
1157                    long eventId, long groupId, java.lang.String type,
1158                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1159                    throws com.liferay.portal.kernel.exception.SystemException,
1160                            com.liferay.portlet.calendar.NoSuchEventException {
1161                    return getPersistence()
1162                                       .findByG_T_PrevAndNext(eventId, groupId, type,
1163                            orderByComparator);
1164            }
1165    
1166            /**
1167            * Returns all the cal events where groupId = &#63; and type = any &#63;.
1168            *
1169            * <p>
1170            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1171            * </p>
1172            *
1173            * @param groupId the group ID
1174            * @param types the types
1175            * @return the matching cal events
1176            * @throws SystemException if a system exception occurred
1177            */
1178            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T(
1179                    long groupId, java.lang.String[] types)
1180                    throws com.liferay.portal.kernel.exception.SystemException {
1181                    return getPersistence().findByG_T(groupId, types);
1182            }
1183    
1184            /**
1185            * Returns a range of all the cal events where groupId = &#63; and type = any &#63;.
1186            *
1187            * <p>
1188            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1189            * </p>
1190            *
1191            * @param groupId the group ID
1192            * @param types the types
1193            * @param start the lower bound of the range of cal events
1194            * @param end the upper bound of the range of cal events (not inclusive)
1195            * @return the range of matching cal events
1196            * @throws SystemException if a system exception occurred
1197            */
1198            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T(
1199                    long groupId, java.lang.String[] types, int start, int end)
1200                    throws com.liferay.portal.kernel.exception.SystemException {
1201                    return getPersistence().findByG_T(groupId, types, start, end);
1202            }
1203    
1204            /**
1205            * Returns an ordered range of all the cal events where groupId = &#63; and type = any &#63;.
1206            *
1207            * <p>
1208            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1209            * </p>
1210            *
1211            * @param groupId the group ID
1212            * @param types the types
1213            * @param start the lower bound of the range of cal events
1214            * @param end the upper bound of the range of cal events (not inclusive)
1215            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1216            * @return the ordered range of matching cal events
1217            * @throws SystemException if a system exception occurred
1218            */
1219            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T(
1220                    long groupId, java.lang.String[] types, int start, int end,
1221                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1222                    throws com.liferay.portal.kernel.exception.SystemException {
1223                    return getPersistence()
1224                                       .findByG_T(groupId, types, start, end, orderByComparator);
1225            }
1226    
1227            /**
1228            * Returns all the cal events that the user has permission to view where groupId = &#63; and type = &#63;.
1229            *
1230            * @param groupId the group ID
1231            * @param type the type
1232            * @return the matching cal events that the user has permission to view
1233            * @throws SystemException if a system exception occurred
1234            */
1235            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T(
1236                    long groupId, java.lang.String type)
1237                    throws com.liferay.portal.kernel.exception.SystemException {
1238                    return getPersistence().filterFindByG_T(groupId, type);
1239            }
1240    
1241            /**
1242            * Returns a range of all the cal events that the user has permission to view where groupId = &#63; and type = &#63;.
1243            *
1244            * <p>
1245            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1246            * </p>
1247            *
1248            * @param groupId the group ID
1249            * @param type the type
1250            * @param start the lower bound of the range of cal events
1251            * @param end the upper bound of the range of cal events (not inclusive)
1252            * @return the range of matching cal events that the user has permission to view
1253            * @throws SystemException if a system exception occurred
1254            */
1255            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T(
1256                    long groupId, java.lang.String type, int start, int end)
1257                    throws com.liferay.portal.kernel.exception.SystemException {
1258                    return getPersistence().filterFindByG_T(groupId, type, start, end);
1259            }
1260    
1261            /**
1262            * Returns an ordered range of all the cal events that the user has permissions to view where groupId = &#63; and type = &#63;.
1263            *
1264            * <p>
1265            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1266            * </p>
1267            *
1268            * @param groupId the group ID
1269            * @param type the type
1270            * @param start the lower bound of the range of cal events
1271            * @param end the upper bound of the range of cal events (not inclusive)
1272            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1273            * @return the ordered range of matching cal events that the user has permission to view
1274            * @throws SystemException if a system exception occurred
1275            */
1276            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T(
1277                    long groupId, java.lang.String type, int start, int end,
1278                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1279                    throws com.liferay.portal.kernel.exception.SystemException {
1280                    return getPersistence()
1281                                       .filterFindByG_T(groupId, type, start, end, orderByComparator);
1282            }
1283    
1284            /**
1285            * Returns the cal events before and after the current cal event in the ordered set of cal events that the user has permission to view where groupId = &#63; and type = &#63;.
1286            *
1287            * @param eventId the primary key of the current cal event
1288            * @param groupId the group ID
1289            * @param type the type
1290            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1291            * @return the previous, current, and next cal event
1292            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
1293            * @throws SystemException if a system exception occurred
1294            */
1295            public static com.liferay.portlet.calendar.model.CalEvent[] filterFindByG_T_PrevAndNext(
1296                    long eventId, long groupId, java.lang.String type,
1297                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1298                    throws com.liferay.portal.kernel.exception.SystemException,
1299                            com.liferay.portlet.calendar.NoSuchEventException {
1300                    return getPersistence()
1301                                       .filterFindByG_T_PrevAndNext(eventId, groupId, type,
1302                            orderByComparator);
1303            }
1304    
1305            /**
1306            * Returns all the cal events that the user has permission to view where groupId = &#63; and type = any &#63;.
1307            *
1308            * @param groupId the group ID
1309            * @param types the types
1310            * @return the matching cal events that the user has permission to view
1311            * @throws SystemException if a system exception occurred
1312            */
1313            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T(
1314                    long groupId, java.lang.String[] types)
1315                    throws com.liferay.portal.kernel.exception.SystemException {
1316                    return getPersistence().filterFindByG_T(groupId, types);
1317            }
1318    
1319            /**
1320            * Returns a range of all the cal events that the user has permission to view where groupId = &#63; and type = any &#63;.
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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1324            * </p>
1325            *
1326            * @param groupId the group ID
1327            * @param types the types
1328            * @param start the lower bound of the range of cal events
1329            * @param end the upper bound of the range of cal events (not inclusive)
1330            * @return the range of matching cal events that the user has permission to view
1331            * @throws SystemException if a system exception occurred
1332            */
1333            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T(
1334                    long groupId, java.lang.String[] types, int start, int end)
1335                    throws com.liferay.portal.kernel.exception.SystemException {
1336                    return getPersistence().filterFindByG_T(groupId, types, start, end);
1337            }
1338    
1339            /**
1340            * Returns an ordered range of all the cal events that the user has permission to view where groupId = &#63; and type = any &#63;.
1341            *
1342            * <p>
1343            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1344            * </p>
1345            *
1346            * @param groupId the group ID
1347            * @param types the types
1348            * @param start the lower bound of the range of cal events
1349            * @param end the upper bound of the range of cal events (not inclusive)
1350            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1351            * @return the ordered range of matching cal events that the user has permission to view
1352            * @throws SystemException if a system exception occurred
1353            */
1354            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T(
1355                    long groupId, java.lang.String[] types, int start, int end,
1356                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1357                    throws com.liferay.portal.kernel.exception.SystemException {
1358                    return getPersistence()
1359                                       .filterFindByG_T(groupId, types, start, end,
1360                            orderByComparator);
1361            }
1362    
1363            /**
1364            * Returns all the cal events where groupId = &#63; and repeating = &#63;.
1365            *
1366            * @param groupId the group ID
1367            * @param repeating the repeating
1368            * @return the matching cal events
1369            * @throws SystemException if a system exception occurred
1370            */
1371            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_R(
1372                    long groupId, boolean repeating)
1373                    throws com.liferay.portal.kernel.exception.SystemException {
1374                    return getPersistence().findByG_R(groupId, repeating);
1375            }
1376    
1377            /**
1378            * Returns a range of all the cal events where groupId = &#63; and repeating = &#63;.
1379            *
1380            * <p>
1381            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1382            * </p>
1383            *
1384            * @param groupId the group ID
1385            * @param repeating the repeating
1386            * @param start the lower bound of the range of cal events
1387            * @param end the upper bound of the range of cal events (not inclusive)
1388            * @return the range of matching cal events
1389            * @throws SystemException if a system exception occurred
1390            */
1391            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_R(
1392                    long groupId, boolean repeating, int start, int end)
1393                    throws com.liferay.portal.kernel.exception.SystemException {
1394                    return getPersistence().findByG_R(groupId, repeating, start, end);
1395            }
1396    
1397            /**
1398            * Returns an ordered range of all the cal events where groupId = &#63; and repeating = &#63;.
1399            *
1400            * <p>
1401            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1402            * </p>
1403            *
1404            * @param groupId the group ID
1405            * @param repeating the repeating
1406            * @param start the lower bound of the range of cal events
1407            * @param end the upper bound of the range of cal events (not inclusive)
1408            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1409            * @return the ordered range of matching cal events
1410            * @throws SystemException if a system exception occurred
1411            */
1412            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_R(
1413                    long groupId, boolean repeating, int start, int end,
1414                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1415                    throws com.liferay.portal.kernel.exception.SystemException {
1416                    return getPersistence()
1417                                       .findByG_R(groupId, repeating, start, end, orderByComparator);
1418            }
1419    
1420            /**
1421            * Returns the first cal event in the ordered set where groupId = &#63; and repeating = &#63;.
1422            *
1423            * @param groupId the group ID
1424            * @param repeating the repeating
1425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1426            * @return the first matching cal event
1427            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
1428            * @throws SystemException if a system exception occurred
1429            */
1430            public static com.liferay.portlet.calendar.model.CalEvent findByG_R_First(
1431                    long groupId, boolean repeating,
1432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1433                    throws com.liferay.portal.kernel.exception.SystemException,
1434                            com.liferay.portlet.calendar.NoSuchEventException {
1435                    return getPersistence()
1436                                       .findByG_R_First(groupId, repeating, orderByComparator);
1437            }
1438    
1439            /**
1440            * Returns the first cal event in the ordered set where groupId = &#63; and repeating = &#63;.
1441            *
1442            * @param groupId the group ID
1443            * @param repeating the repeating
1444            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1445            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
1446            * @throws SystemException if a system exception occurred
1447            */
1448            public static com.liferay.portlet.calendar.model.CalEvent fetchByG_R_First(
1449                    long groupId, boolean repeating,
1450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1451                    throws com.liferay.portal.kernel.exception.SystemException {
1452                    return getPersistence()
1453                                       .fetchByG_R_First(groupId, repeating, orderByComparator);
1454            }
1455    
1456            /**
1457            * Returns the last cal event in the ordered set where groupId = &#63; and repeating = &#63;.
1458            *
1459            * @param groupId the group ID
1460            * @param repeating the repeating
1461            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1462            * @return the last matching cal event
1463            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
1464            * @throws SystemException if a system exception occurred
1465            */
1466            public static com.liferay.portlet.calendar.model.CalEvent findByG_R_Last(
1467                    long groupId, boolean repeating,
1468                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1469                    throws com.liferay.portal.kernel.exception.SystemException,
1470                            com.liferay.portlet.calendar.NoSuchEventException {
1471                    return getPersistence()
1472                                       .findByG_R_Last(groupId, repeating, orderByComparator);
1473            }
1474    
1475            /**
1476            * Returns the last cal event in the ordered set where groupId = &#63; and repeating = &#63;.
1477            *
1478            * @param groupId the group ID
1479            * @param repeating the repeating
1480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1481            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
1482            * @throws SystemException if a system exception occurred
1483            */
1484            public static com.liferay.portlet.calendar.model.CalEvent fetchByG_R_Last(
1485                    long groupId, boolean repeating,
1486                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1487                    throws com.liferay.portal.kernel.exception.SystemException {
1488                    return getPersistence()
1489                                       .fetchByG_R_Last(groupId, repeating, orderByComparator);
1490            }
1491    
1492            /**
1493            * Returns the cal events before and after the current cal event in the ordered set where groupId = &#63; and repeating = &#63;.
1494            *
1495            * @param eventId the primary key of the current cal event
1496            * @param groupId the group ID
1497            * @param repeating the repeating
1498            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1499            * @return the previous, current, and next cal event
1500            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
1501            * @throws SystemException if a system exception occurred
1502            */
1503            public static com.liferay.portlet.calendar.model.CalEvent[] findByG_R_PrevAndNext(
1504                    long eventId, long groupId, boolean repeating,
1505                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1506                    throws com.liferay.portal.kernel.exception.SystemException,
1507                            com.liferay.portlet.calendar.NoSuchEventException {
1508                    return getPersistence()
1509                                       .findByG_R_PrevAndNext(eventId, groupId, repeating,
1510                            orderByComparator);
1511            }
1512    
1513            /**
1514            * Returns all the cal events that the user has permission to view where groupId = &#63; and repeating = &#63;.
1515            *
1516            * @param groupId the group ID
1517            * @param repeating the repeating
1518            * @return the matching cal events that the user has permission to view
1519            * @throws SystemException if a system exception occurred
1520            */
1521            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_R(
1522                    long groupId, boolean repeating)
1523                    throws com.liferay.portal.kernel.exception.SystemException {
1524                    return getPersistence().filterFindByG_R(groupId, repeating);
1525            }
1526    
1527            /**
1528            * Returns a range of all the cal events that the user has permission to view where groupId = &#63; and repeating = &#63;.
1529            *
1530            * <p>
1531            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1532            * </p>
1533            *
1534            * @param groupId the group ID
1535            * @param repeating the repeating
1536            * @param start the lower bound of the range of cal events
1537            * @param end the upper bound of the range of cal events (not inclusive)
1538            * @return the range of matching cal events that the user has permission to view
1539            * @throws SystemException if a system exception occurred
1540            */
1541            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_R(
1542                    long groupId, boolean repeating, int start, int end)
1543                    throws com.liferay.portal.kernel.exception.SystemException {
1544                    return getPersistence().filterFindByG_R(groupId, repeating, start, end);
1545            }
1546    
1547            /**
1548            * Returns an ordered range of all the cal events that the user has permissions to view where groupId = &#63; and repeating = &#63;.
1549            *
1550            * <p>
1551            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1552            * </p>
1553            *
1554            * @param groupId the group ID
1555            * @param repeating the repeating
1556            * @param start the lower bound of the range of cal events
1557            * @param end the upper bound of the range of cal events (not inclusive)
1558            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1559            * @return the ordered range of matching cal events that the user has permission to view
1560            * @throws SystemException if a system exception occurred
1561            */
1562            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_R(
1563                    long groupId, boolean repeating, int start, int end,
1564                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1565                    throws com.liferay.portal.kernel.exception.SystemException {
1566                    return getPersistence()
1567                                       .filterFindByG_R(groupId, repeating, start, end,
1568                            orderByComparator);
1569            }
1570    
1571            /**
1572            * Returns the cal events before and after the current cal event in the ordered set of cal events that the user has permission to view where groupId = &#63; and repeating = &#63;.
1573            *
1574            * @param eventId the primary key of the current cal event
1575            * @param groupId the group ID
1576            * @param repeating the repeating
1577            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1578            * @return the previous, current, and next cal event
1579            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
1580            * @throws SystemException if a system exception occurred
1581            */
1582            public static com.liferay.portlet.calendar.model.CalEvent[] filterFindByG_R_PrevAndNext(
1583                    long eventId, long groupId, boolean repeating,
1584                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1585                    throws com.liferay.portal.kernel.exception.SystemException,
1586                            com.liferay.portlet.calendar.NoSuchEventException {
1587                    return getPersistence()
1588                                       .filterFindByG_R_PrevAndNext(eventId, groupId, repeating,
1589                            orderByComparator);
1590            }
1591    
1592            /**
1593            * Returns all the cal events where groupId = &#63; and type = &#63; and repeating = &#63;.
1594            *
1595            * @param groupId the group ID
1596            * @param type the type
1597            * @param repeating the repeating
1598            * @return the matching cal events
1599            * @throws SystemException if a system exception occurred
1600            */
1601            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T_R(
1602                    long groupId, java.lang.String type, boolean repeating)
1603                    throws com.liferay.portal.kernel.exception.SystemException {
1604                    return getPersistence().findByG_T_R(groupId, type, repeating);
1605            }
1606    
1607            /**
1608            * Returns a range of all the cal events where groupId = &#63; and type = &#63; and repeating = &#63;.
1609            *
1610            * <p>
1611            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1612            * </p>
1613            *
1614            * @param groupId the group ID
1615            * @param type the type
1616            * @param repeating the repeating
1617            * @param start the lower bound of the range of cal events
1618            * @param end the upper bound of the range of cal events (not inclusive)
1619            * @return the range of matching cal events
1620            * @throws SystemException if a system exception occurred
1621            */
1622            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T_R(
1623                    long groupId, java.lang.String type, boolean repeating, int start,
1624                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1625                    return getPersistence().findByG_T_R(groupId, type, repeating, start, end);
1626            }
1627    
1628            /**
1629            * Returns an ordered range of all the cal events where groupId = &#63; and type = &#63; and repeating = &#63;.
1630            *
1631            * <p>
1632            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1633            * </p>
1634            *
1635            * @param groupId the group ID
1636            * @param type the type
1637            * @param repeating the repeating
1638            * @param start the lower bound of the range of cal events
1639            * @param end the upper bound of the range of cal events (not inclusive)
1640            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1641            * @return the ordered range of matching cal events
1642            * @throws SystemException if a system exception occurred
1643            */
1644            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T_R(
1645                    long groupId, java.lang.String type, boolean repeating, int start,
1646                    int end,
1647                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1648                    throws com.liferay.portal.kernel.exception.SystemException {
1649                    return getPersistence()
1650                                       .findByG_T_R(groupId, type, repeating, start, end,
1651                            orderByComparator);
1652            }
1653    
1654            /**
1655            * Returns the first cal event in the ordered set where groupId = &#63; and type = &#63; and repeating = &#63;.
1656            *
1657            * @param groupId the group ID
1658            * @param type the type
1659            * @param repeating the repeating
1660            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1661            * @return the first matching cal event
1662            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
1663            * @throws SystemException if a system exception occurred
1664            */
1665            public static com.liferay.portlet.calendar.model.CalEvent findByG_T_R_First(
1666                    long groupId, java.lang.String type, boolean repeating,
1667                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1668                    throws com.liferay.portal.kernel.exception.SystemException,
1669                            com.liferay.portlet.calendar.NoSuchEventException {
1670                    return getPersistence()
1671                                       .findByG_T_R_First(groupId, type, repeating,
1672                            orderByComparator);
1673            }
1674    
1675            /**
1676            * Returns the first cal event in the ordered set where groupId = &#63; and type = &#63; and repeating = &#63;.
1677            *
1678            * @param groupId the group ID
1679            * @param type the type
1680            * @param repeating the repeating
1681            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1682            * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found
1683            * @throws SystemException if a system exception occurred
1684            */
1685            public static com.liferay.portlet.calendar.model.CalEvent fetchByG_T_R_First(
1686                    long groupId, java.lang.String type, boolean repeating,
1687                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1688                    throws com.liferay.portal.kernel.exception.SystemException {
1689                    return getPersistence()
1690                                       .fetchByG_T_R_First(groupId, type, repeating,
1691                            orderByComparator);
1692            }
1693    
1694            /**
1695            * Returns the last cal event in the ordered set where groupId = &#63; and type = &#63; and repeating = &#63;.
1696            *
1697            * @param groupId the group ID
1698            * @param type the type
1699            * @param repeating the repeating
1700            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1701            * @return the last matching cal event
1702            * @throws com.liferay.portlet.calendar.NoSuchEventException if a matching cal event could not be found
1703            * @throws SystemException if a system exception occurred
1704            */
1705            public static com.liferay.portlet.calendar.model.CalEvent findByG_T_R_Last(
1706                    long groupId, java.lang.String type, boolean repeating,
1707                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1708                    throws com.liferay.portal.kernel.exception.SystemException,
1709                            com.liferay.portlet.calendar.NoSuchEventException {
1710                    return getPersistence()
1711                                       .findByG_T_R_Last(groupId, type, repeating, orderByComparator);
1712            }
1713    
1714            /**
1715            * Returns the last cal event in the ordered set where groupId = &#63; and type = &#63; and repeating = &#63;.
1716            *
1717            * @param groupId the group ID
1718            * @param type the type
1719            * @param repeating the repeating
1720            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1721            * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found
1722            * @throws SystemException if a system exception occurred
1723            */
1724            public static com.liferay.portlet.calendar.model.CalEvent fetchByG_T_R_Last(
1725                    long groupId, java.lang.String type, boolean repeating,
1726                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1727                    throws com.liferay.portal.kernel.exception.SystemException {
1728                    return getPersistence()
1729                                       .fetchByG_T_R_Last(groupId, type, repeating,
1730                            orderByComparator);
1731            }
1732    
1733            /**
1734            * Returns the cal events before and after the current cal event in the ordered set where groupId = &#63; and type = &#63; and repeating = &#63;.
1735            *
1736            * @param eventId the primary key of the current cal event
1737            * @param groupId the group ID
1738            * @param type the type
1739            * @param repeating the repeating
1740            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1741            * @return the previous, current, and next cal event
1742            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
1743            * @throws SystemException if a system exception occurred
1744            */
1745            public static com.liferay.portlet.calendar.model.CalEvent[] findByG_T_R_PrevAndNext(
1746                    long eventId, long groupId, java.lang.String type, boolean repeating,
1747                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1748                    throws com.liferay.portal.kernel.exception.SystemException,
1749                            com.liferay.portlet.calendar.NoSuchEventException {
1750                    return getPersistence()
1751                                       .findByG_T_R_PrevAndNext(eventId, groupId, type, repeating,
1752                            orderByComparator);
1753            }
1754    
1755            /**
1756            * Returns all the cal events where groupId = &#63; and type = any &#63; and repeating = &#63;.
1757            *
1758            * <p>
1759            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1760            * </p>
1761            *
1762            * @param groupId the group ID
1763            * @param types the types
1764            * @param repeating the repeating
1765            * @return the matching cal events
1766            * @throws SystemException if a system exception occurred
1767            */
1768            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T_R(
1769                    long groupId, java.lang.String[] types, boolean repeating)
1770                    throws com.liferay.portal.kernel.exception.SystemException {
1771                    return getPersistence().findByG_T_R(groupId, types, repeating);
1772            }
1773    
1774            /**
1775            * Returns a range of all the cal events where groupId = &#63; and type = any &#63; and repeating = &#63;.
1776            *
1777            * <p>
1778            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1779            * </p>
1780            *
1781            * @param groupId the group ID
1782            * @param types the types
1783            * @param repeating the repeating
1784            * @param start the lower bound of the range of cal events
1785            * @param end the upper bound of the range of cal events (not inclusive)
1786            * @return the range of matching cal events
1787            * @throws SystemException if a system exception occurred
1788            */
1789            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T_R(
1790                    long groupId, java.lang.String[] types, boolean repeating, int start,
1791                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1792                    return getPersistence()
1793                                       .findByG_T_R(groupId, types, repeating, start, end);
1794            }
1795    
1796            /**
1797            * Returns an ordered range of all the cal events where groupId = &#63; and type = any &#63; and repeating = &#63;.
1798            *
1799            * <p>
1800            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1801            * </p>
1802            *
1803            * @param groupId the group ID
1804            * @param types the types
1805            * @param repeating the repeating
1806            * @param start the lower bound of the range of cal events
1807            * @param end the upper bound of the range of cal events (not inclusive)
1808            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1809            * @return the ordered range of matching cal events
1810            * @throws SystemException if a system exception occurred
1811            */
1812            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findByG_T_R(
1813                    long groupId, java.lang.String[] types, boolean repeating, int start,
1814                    int end,
1815                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1816                    throws com.liferay.portal.kernel.exception.SystemException {
1817                    return getPersistence()
1818                                       .findByG_T_R(groupId, types, repeating, start, end,
1819                            orderByComparator);
1820            }
1821    
1822            /**
1823            * Returns all the cal events that the user has permission to view where groupId = &#63; and type = &#63; and repeating = &#63;.
1824            *
1825            * @param groupId the group ID
1826            * @param type the type
1827            * @param repeating the repeating
1828            * @return the matching cal events that the user has permission to view
1829            * @throws SystemException if a system exception occurred
1830            */
1831            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T_R(
1832                    long groupId, java.lang.String type, boolean repeating)
1833                    throws com.liferay.portal.kernel.exception.SystemException {
1834                    return getPersistence().filterFindByG_T_R(groupId, type, repeating);
1835            }
1836    
1837            /**
1838            * Returns a range of all the cal events that the user has permission to view where groupId = &#63; and type = &#63; and repeating = &#63;.
1839            *
1840            * <p>
1841            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1842            * </p>
1843            *
1844            * @param groupId the group ID
1845            * @param type the type
1846            * @param repeating the repeating
1847            * @param start the lower bound of the range of cal events
1848            * @param end the upper bound of the range of cal events (not inclusive)
1849            * @return the range of matching cal events that the user has permission to view
1850            * @throws SystemException if a system exception occurred
1851            */
1852            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T_R(
1853                    long groupId, java.lang.String type, boolean repeating, int start,
1854                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1855                    return getPersistence()
1856                                       .filterFindByG_T_R(groupId, type, repeating, start, end);
1857            }
1858    
1859            /**
1860            * Returns an ordered range of all the cal events that the user has permissions to view where groupId = &#63; and type = &#63; and repeating = &#63;.
1861            *
1862            * <p>
1863            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1864            * </p>
1865            *
1866            * @param groupId the group ID
1867            * @param type the type
1868            * @param repeating the repeating
1869            * @param start the lower bound of the range of cal events
1870            * @param end the upper bound of the range of cal events (not inclusive)
1871            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1872            * @return the ordered range of matching cal events that the user has permission to view
1873            * @throws SystemException if a system exception occurred
1874            */
1875            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T_R(
1876                    long groupId, java.lang.String type, boolean repeating, int start,
1877                    int end,
1878                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1879                    throws com.liferay.portal.kernel.exception.SystemException {
1880                    return getPersistence()
1881                                       .filterFindByG_T_R(groupId, type, repeating, start, end,
1882                            orderByComparator);
1883            }
1884    
1885            /**
1886            * Returns the cal events before and after the current cal event in the ordered set of cal events that the user has permission to view where groupId = &#63; and type = &#63; and repeating = &#63;.
1887            *
1888            * @param eventId the primary key of the current cal event
1889            * @param groupId the group ID
1890            * @param type the type
1891            * @param repeating the repeating
1892            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1893            * @return the previous, current, and next cal event
1894            * @throws com.liferay.portlet.calendar.NoSuchEventException if a cal event with the primary key could not be found
1895            * @throws SystemException if a system exception occurred
1896            */
1897            public static com.liferay.portlet.calendar.model.CalEvent[] filterFindByG_T_R_PrevAndNext(
1898                    long eventId, long groupId, java.lang.String type, boolean repeating,
1899                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1900                    throws com.liferay.portal.kernel.exception.SystemException,
1901                            com.liferay.portlet.calendar.NoSuchEventException {
1902                    return getPersistence()
1903                                       .filterFindByG_T_R_PrevAndNext(eventId, groupId, type,
1904                            repeating, orderByComparator);
1905            }
1906    
1907            /**
1908            * Returns all the cal events that the user has permission to view where groupId = &#63; and type = any &#63; and repeating = &#63;.
1909            *
1910            * @param groupId the group ID
1911            * @param types the types
1912            * @param repeating the repeating
1913            * @return the matching cal events that the user has permission to view
1914            * @throws SystemException if a system exception occurred
1915            */
1916            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T_R(
1917                    long groupId, java.lang.String[] types, boolean repeating)
1918                    throws com.liferay.portal.kernel.exception.SystemException {
1919                    return getPersistence().filterFindByG_T_R(groupId, types, repeating);
1920            }
1921    
1922            /**
1923            * Returns a range of all the cal events that the user has permission to view where groupId = &#63; and type = any &#63; and repeating = &#63;.
1924            *
1925            * <p>
1926            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1927            * </p>
1928            *
1929            * @param groupId the group ID
1930            * @param types the types
1931            * @param repeating the repeating
1932            * @param start the lower bound of the range of cal events
1933            * @param end the upper bound of the range of cal events (not inclusive)
1934            * @return the range of matching cal events that the user has permission to view
1935            * @throws SystemException if a system exception occurred
1936            */
1937            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T_R(
1938                    long groupId, java.lang.String[] types, boolean repeating, int start,
1939                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1940                    return getPersistence()
1941                                       .filterFindByG_T_R(groupId, types, repeating, start, end);
1942            }
1943    
1944            /**
1945            * Returns an ordered range of all the cal events that the user has permission to view where groupId = &#63; and type = any &#63; and repeating = &#63;.
1946            *
1947            * <p>
1948            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1949            * </p>
1950            *
1951            * @param groupId the group ID
1952            * @param types the types
1953            * @param repeating the repeating
1954            * @param start the lower bound of the range of cal events
1955            * @param end the upper bound of the range of cal events (not inclusive)
1956            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1957            * @return the ordered range of matching cal events that the user has permission to view
1958            * @throws SystemException if a system exception occurred
1959            */
1960            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> filterFindByG_T_R(
1961                    long groupId, java.lang.String[] types, boolean repeating, int start,
1962                    int end,
1963                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1964                    throws com.liferay.portal.kernel.exception.SystemException {
1965                    return getPersistence()
1966                                       .filterFindByG_T_R(groupId, types, repeating, start, end,
1967                            orderByComparator);
1968            }
1969    
1970            /**
1971            * Returns all the cal events.
1972            *
1973            * @return the cal events
1974            * @throws SystemException if a system exception occurred
1975            */
1976            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findAll()
1977                    throws com.liferay.portal.kernel.exception.SystemException {
1978                    return getPersistence().findAll();
1979            }
1980    
1981            /**
1982            * Returns a range of all the cal events.
1983            *
1984            * <p>
1985            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1986            * </p>
1987            *
1988            * @param start the lower bound of the range of cal events
1989            * @param end the upper bound of the range of cal events (not inclusive)
1990            * @return the range of cal events
1991            * @throws SystemException if a system exception occurred
1992            */
1993            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findAll(
1994                    int start, int end)
1995                    throws com.liferay.portal.kernel.exception.SystemException {
1996                    return getPersistence().findAll(start, end);
1997            }
1998    
1999            /**
2000            * Returns an ordered range of all the cal events.
2001            *
2002            * <p>
2003            * 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2004            * </p>
2005            *
2006            * @param start the lower bound of the range of cal events
2007            * @param end the upper bound of the range of cal events (not inclusive)
2008            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2009            * @return the ordered range of cal events
2010            * @throws SystemException if a system exception occurred
2011            */
2012            public static java.util.List<com.liferay.portlet.calendar.model.CalEvent> findAll(
2013                    int start, int end,
2014                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2015                    throws com.liferay.portal.kernel.exception.SystemException {
2016                    return getPersistence().findAll(start, end, orderByComparator);
2017            }
2018    
2019            /**
2020            * Removes all the cal events where uuid = &#63; from the database.
2021            *
2022            * @param uuid the uuid
2023            * @throws SystemException if a system exception occurred
2024            */
2025            public static void removeByUuid(java.lang.String uuid)
2026                    throws com.liferay.portal.kernel.exception.SystemException {
2027                    getPersistence().removeByUuid(uuid);
2028            }
2029    
2030            /**
2031            * Removes the cal event where uuid = &#63; and groupId = &#63; from the database.
2032            *
2033            * @param uuid the uuid
2034            * @param groupId the group ID
2035            * @return the cal event that was removed
2036            * @throws SystemException if a system exception occurred
2037            */
2038            public static com.liferay.portlet.calendar.model.CalEvent removeByUUID_G(
2039                    java.lang.String uuid, long groupId)
2040                    throws com.liferay.portal.kernel.exception.SystemException,
2041                            com.liferay.portlet.calendar.NoSuchEventException {
2042                    return getPersistence().removeByUUID_G(uuid, groupId);
2043            }
2044    
2045            /**
2046            * Removes all the cal events where uuid = &#63; and companyId = &#63; from the database.
2047            *
2048            * @param uuid the uuid
2049            * @param companyId the company ID
2050            * @throws SystemException if a system exception occurred
2051            */
2052            public static void removeByUuid_C(java.lang.String uuid, long companyId)
2053                    throws com.liferay.portal.kernel.exception.SystemException {
2054                    getPersistence().removeByUuid_C(uuid, companyId);
2055            }
2056    
2057            /**
2058            * Removes all the cal events where companyId = &#63; from the database.
2059            *
2060            * @param companyId the company ID
2061            * @throws SystemException if a system exception occurred
2062            */
2063            public static void removeByCompanyId(long companyId)
2064                    throws com.liferay.portal.kernel.exception.SystemException {
2065                    getPersistence().removeByCompanyId(companyId);
2066            }
2067    
2068            /**
2069            * Removes all the cal events where groupId = &#63; from the database.
2070            *
2071            * @param groupId the group ID
2072            * @throws SystemException if a system exception occurred
2073            */
2074            public static void removeByGroupId(long groupId)
2075                    throws com.liferay.portal.kernel.exception.SystemException {
2076                    getPersistence().removeByGroupId(groupId);
2077            }
2078    
2079            /**
2080            * Removes all the cal events where remindBy &ne; &#63; from the database.
2081            *
2082            * @param remindBy the remind by
2083            * @throws SystemException if a system exception occurred
2084            */
2085            public static void removeByNotRemindBy(int remindBy)
2086                    throws com.liferay.portal.kernel.exception.SystemException {
2087                    getPersistence().removeByNotRemindBy(remindBy);
2088            }
2089    
2090            /**
2091            * Removes all the cal events where groupId = &#63; and type = &#63; from the database.
2092            *
2093            * @param groupId the group ID
2094            * @param type the type
2095            * @throws SystemException if a system exception occurred
2096            */
2097            public static void removeByG_T(long groupId, java.lang.String type)
2098                    throws com.liferay.portal.kernel.exception.SystemException {
2099                    getPersistence().removeByG_T(groupId, type);
2100            }
2101    
2102            /**
2103            * Removes all the cal events where groupId = &#63; and repeating = &#63; from the database.
2104            *
2105            * @param groupId the group ID
2106            * @param repeating the repeating
2107            * @throws SystemException if a system exception occurred
2108            */
2109            public static void removeByG_R(long groupId, boolean repeating)
2110                    throws com.liferay.portal.kernel.exception.SystemException {
2111                    getPersistence().removeByG_R(groupId, repeating);
2112            }
2113    
2114            /**
2115            * Removes all the cal events where groupId = &#63; and type = &#63; and repeating = &#63; from the database.
2116            *
2117            * @param groupId the group ID
2118            * @param type the type
2119            * @param repeating the repeating
2120            * @throws SystemException if a system exception occurred
2121            */
2122            public static void removeByG_T_R(long groupId, java.lang.String type,
2123                    boolean repeating)
2124                    throws com.liferay.portal.kernel.exception.SystemException {
2125                    getPersistence().removeByG_T_R(groupId, type, repeating);
2126            }
2127    
2128            /**
2129            * Removes all the cal events from the database.
2130            *
2131            * @throws SystemException if a system exception occurred
2132            */
2133            public static void removeAll()
2134                    throws com.liferay.portal.kernel.exception.SystemException {
2135                    getPersistence().removeAll();
2136            }
2137    
2138            /**
2139            * Returns the number of cal events where uuid = &#63;.
2140            *
2141            * @param uuid the uuid
2142            * @return the number of matching cal events
2143            * @throws SystemException if a system exception occurred
2144            */
2145            public static int countByUuid(java.lang.String uuid)
2146                    throws com.liferay.portal.kernel.exception.SystemException {
2147                    return getPersistence().countByUuid(uuid);
2148            }
2149    
2150            /**
2151            * Returns the number of cal events where uuid = &#63; and groupId = &#63;.
2152            *
2153            * @param uuid the uuid
2154            * @param groupId the group ID
2155            * @return the number of matching cal events
2156            * @throws SystemException if a system exception occurred
2157            */
2158            public static int countByUUID_G(java.lang.String uuid, long groupId)
2159                    throws com.liferay.portal.kernel.exception.SystemException {
2160                    return getPersistence().countByUUID_G(uuid, groupId);
2161            }
2162    
2163            /**
2164            * Returns the number of cal events where uuid = &#63; and companyId = &#63;.
2165            *
2166            * @param uuid the uuid
2167            * @param companyId the company ID
2168            * @return the number of matching cal events
2169            * @throws SystemException if a system exception occurred
2170            */
2171            public static int countByUuid_C(java.lang.String uuid, long companyId)
2172                    throws com.liferay.portal.kernel.exception.SystemException {
2173                    return getPersistence().countByUuid_C(uuid, companyId);
2174            }
2175    
2176            /**
2177            * Returns the number of cal events where companyId = &#63;.
2178            *
2179            * @param companyId the company ID
2180            * @return the number of matching cal events
2181            * @throws SystemException if a system exception occurred
2182            */
2183            public static int countByCompanyId(long companyId)
2184                    throws com.liferay.portal.kernel.exception.SystemException {
2185                    return getPersistence().countByCompanyId(companyId);
2186            }
2187    
2188            /**
2189            * Returns the number of cal events where groupId = &#63;.
2190            *
2191            * @param groupId the group ID
2192            * @return the number of matching cal events
2193            * @throws SystemException if a system exception occurred
2194            */
2195            public static int countByGroupId(long groupId)
2196                    throws com.liferay.portal.kernel.exception.SystemException {
2197                    return getPersistence().countByGroupId(groupId);
2198            }
2199    
2200            /**
2201            * Returns the number of cal events that the user has permission to view where groupId = &#63;.
2202            *
2203            * @param groupId the group ID
2204            * @return the number of matching cal events that the user has permission to view
2205            * @throws SystemException if a system exception occurred
2206            */
2207            public static int filterCountByGroupId(long groupId)
2208                    throws com.liferay.portal.kernel.exception.SystemException {
2209                    return getPersistence().filterCountByGroupId(groupId);
2210            }
2211    
2212            /**
2213            * Returns the number of cal events where remindBy &ne; &#63;.
2214            *
2215            * @param remindBy the remind by
2216            * @return the number of matching cal events
2217            * @throws SystemException if a system exception occurred
2218            */
2219            public static int countByNotRemindBy(int remindBy)
2220                    throws com.liferay.portal.kernel.exception.SystemException {
2221                    return getPersistence().countByNotRemindBy(remindBy);
2222            }
2223    
2224            /**
2225            * Returns the number of cal events where groupId = &#63; and type = &#63;.
2226            *
2227            * @param groupId the group ID
2228            * @param type the type
2229            * @return the number of matching cal events
2230            * @throws SystemException if a system exception occurred
2231            */
2232            public static int countByG_T(long groupId, java.lang.String type)
2233                    throws com.liferay.portal.kernel.exception.SystemException {
2234                    return getPersistence().countByG_T(groupId, type);
2235            }
2236    
2237            /**
2238            * Returns the number of cal events where groupId = &#63; and type = any &#63;.
2239            *
2240            * @param groupId the group ID
2241            * @param types the types
2242            * @return the number of matching cal events
2243            * @throws SystemException if a system exception occurred
2244            */
2245            public static int countByG_T(long groupId, java.lang.String[] types)
2246                    throws com.liferay.portal.kernel.exception.SystemException {
2247                    return getPersistence().countByG_T(groupId, types);
2248            }
2249    
2250            /**
2251            * Returns the number of cal events that the user has permission to view where groupId = &#63; and type = &#63;.
2252            *
2253            * @param groupId the group ID
2254            * @param type the type
2255            * @return the number of matching cal events that the user has permission to view
2256            * @throws SystemException if a system exception occurred
2257            */
2258            public static int filterCountByG_T(long groupId, java.lang.String type)
2259                    throws com.liferay.portal.kernel.exception.SystemException {
2260                    return getPersistence().filterCountByG_T(groupId, type);
2261            }
2262    
2263            /**
2264            * Returns the number of cal events that the user has permission to view where groupId = &#63; and type = any &#63;.
2265            *
2266            * @param groupId the group ID
2267            * @param types the types
2268            * @return the number of matching cal events that the user has permission to view
2269            * @throws SystemException if a system exception occurred
2270            */
2271            public static int filterCountByG_T(long groupId, java.lang.String[] types)
2272                    throws com.liferay.portal.kernel.exception.SystemException {
2273                    return getPersistence().filterCountByG_T(groupId, types);
2274            }
2275    
2276            /**
2277            * Returns the number of cal events where groupId = &#63; and repeating = &#63;.
2278            *
2279            * @param groupId the group ID
2280            * @param repeating the repeating
2281            * @return the number of matching cal events
2282            * @throws SystemException if a system exception occurred
2283            */
2284            public static int countByG_R(long groupId, boolean repeating)
2285                    throws com.liferay.portal.kernel.exception.SystemException {
2286                    return getPersistence().countByG_R(groupId, repeating);
2287            }
2288    
2289            /**
2290            * Returns the number of cal events that the user has permission to view where groupId = &#63; and repeating = &#63;.
2291            *
2292            * @param groupId the group ID
2293            * @param repeating the repeating
2294            * @return the number of matching cal events that the user has permission to view
2295            * @throws SystemException if a system exception occurred
2296            */
2297            public static int filterCountByG_R(long groupId, boolean repeating)
2298                    throws com.liferay.portal.kernel.exception.SystemException {
2299                    return getPersistence().filterCountByG_R(groupId, repeating);
2300            }
2301    
2302            /**
2303            * Returns the number of cal events where groupId = &#63; and type = &#63; and repeating = &#63;.
2304            *
2305            * @param groupId the group ID
2306            * @param type the type
2307            * @param repeating the repeating
2308            * @return the number of matching cal events
2309            * @throws SystemException if a system exception occurred
2310            */
2311            public static int countByG_T_R(long groupId, java.lang.String type,
2312                    boolean repeating)
2313                    throws com.liferay.portal.kernel.exception.SystemException {
2314                    return getPersistence().countByG_T_R(groupId, type, repeating);
2315            }
2316    
2317            /**
2318            * Returns the number of cal events where groupId = &#63; and type = any &#63; and repeating = &#63;.
2319            *
2320            * @param groupId the group ID
2321            * @param types the types
2322            * @param repeating the repeating
2323            * @return the number of matching cal events
2324            * @throws SystemException if a system exception occurred
2325            */
2326            public static int countByG_T_R(long groupId, java.lang.String[] types,
2327                    boolean repeating)
2328                    throws com.liferay.portal.kernel.exception.SystemException {
2329                    return getPersistence().countByG_T_R(groupId, types, repeating);
2330            }
2331    
2332            /**
2333            * Returns the number of cal events that the user has permission to view where groupId = &#63; and type = &#63; and repeating = &#63;.
2334            *
2335            * @param groupId the group ID
2336            * @param type the type
2337            * @param repeating the repeating
2338            * @return the number of matching cal events that the user has permission to view
2339            * @throws SystemException if a system exception occurred
2340            */
2341            public static int filterCountByG_T_R(long groupId, java.lang.String type,
2342                    boolean repeating)
2343                    throws com.liferay.portal.kernel.exception.SystemException {
2344                    return getPersistence().filterCountByG_T_R(groupId, type, repeating);
2345            }
2346    
2347            /**
2348            * Returns the number of cal events that the user has permission to view where groupId = &#63; and type = any &#63; and repeating = &#63;.
2349            *
2350            * @param groupId the group ID
2351            * @param types the types
2352            * @param repeating the repeating
2353            * @return the number of matching cal events that the user has permission to view
2354            * @throws SystemException if a system exception occurred
2355            */
2356            public static int filterCountByG_T_R(long groupId,
2357                    java.lang.String[] types, boolean repeating)
2358                    throws com.liferay.portal.kernel.exception.SystemException {
2359                    return getPersistence().filterCountByG_T_R(groupId, types, repeating);
2360            }
2361    
2362            /**
2363            * Returns the number of cal events.
2364            *
2365            * @return the number of cal events
2366            * @throws SystemException if a system exception occurred
2367            */
2368            public static int countAll()
2369                    throws com.liferay.portal.kernel.exception.SystemException {
2370                    return getPersistence().countAll();
2371            }
2372    
2373            public static CalEventPersistence getPersistence() {
2374                    if (_persistence == null) {
2375                            _persistence = (CalEventPersistence)PortalBeanLocatorUtil.locate(CalEventPersistence.class.getName());
2376    
2377                            ReferenceRegistry.registerReference(CalEventUtil.class,
2378                                    "_persistence");
2379                    }
2380    
2381                    return _persistence;
2382            }
2383    
2384            /**
2385             * @deprecated
2386             */
2387            public void setPersistence(CalEventPersistence persistence) {
2388            }
2389    
2390            private static CalEventPersistence _persistence;
2391    }