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