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