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