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