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