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