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