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