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