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.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.model.EmailAddress; 020 021 /** 022 * The persistence interface for the email address service. 023 * 024 * <p> 025 * Caching information and settings can be found in <code>portal.properties</code> 026 * </p> 027 * 028 * @author Brian Wing Shun Chan 029 * @see com.liferay.portal.service.persistence.impl.EmailAddressPersistenceImpl 030 * @see EmailAddressUtil 031 * @generated 032 */ 033 @ProviderType 034 public interface EmailAddressPersistence extends BasePersistence<EmailAddress> { 035 /* 036 * NOTE FOR DEVELOPERS: 037 * 038 * Never modify or reference this interface directly. Always use {@link EmailAddressUtil} to access the email address persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 039 */ 040 041 /** 042 * Returns all the email addresses where uuid = ?. 043 * 044 * @param uuid the uuid 045 * @return the matching email addresses 046 */ 047 public java.util.List<EmailAddress> findByUuid(java.lang.String uuid); 048 049 /** 050 * Returns a range of all the email addresses where uuid = ?. 051 * 052 * <p> 053 * 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 EmailAddressModelImpl}. 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. 054 * </p> 055 * 056 * @param uuid the uuid 057 * @param start the lower bound of the range of email addresses 058 * @param end the upper bound of the range of email addresses (not inclusive) 059 * @return the range of matching email addresses 060 */ 061 public java.util.List<EmailAddress> findByUuid(java.lang.String uuid, 062 int start, int end); 063 064 /** 065 * Returns an ordered range of all the email addresses where uuid = ?. 066 * 067 * <p> 068 * 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 EmailAddressModelImpl}. 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. 069 * </p> 070 * 071 * @param uuid the uuid 072 * @param start the lower bound of the range of email addresses 073 * @param end the upper bound of the range of email addresses (not inclusive) 074 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 075 * @return the ordered range of matching email addresses 076 */ 077 public java.util.List<EmailAddress> findByUuid(java.lang.String uuid, 078 int start, int end, 079 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 080 081 /** 082 * Returns an ordered range of all the email addresses where uuid = ?. 083 * 084 * <p> 085 * 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 EmailAddressModelImpl}. 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. 086 * </p> 087 * 088 * @param uuid the uuid 089 * @param start the lower bound of the range of email addresses 090 * @param end the upper bound of the range of email addresses (not inclusive) 091 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 092 * @param retrieveFromCache whether to retrieve from the finder cache 093 * @return the ordered range of matching email addresses 094 */ 095 public java.util.List<EmailAddress> findByUuid(java.lang.String uuid, 096 int start, int end, 097 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator, 098 boolean retrieveFromCache); 099 100 /** 101 * Returns the first email address in the ordered set where uuid = ?. 102 * 103 * @param uuid the uuid 104 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 105 * @return the first matching email address 106 * @throws NoSuchEmailAddressException if a matching email address could not be found 107 */ 108 public EmailAddress findByUuid_First(java.lang.String uuid, 109 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 110 throws com.liferay.portal.exception.NoSuchEmailAddressException; 111 112 /** 113 * Returns the first email address in the ordered set where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 117 * @return the first matching email address, or <code>null</code> if a matching email address could not be found 118 */ 119 public EmailAddress fetchByUuid_First(java.lang.String uuid, 120 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 121 122 /** 123 * Returns the last email address in the ordered set where uuid = ?. 124 * 125 * @param uuid the uuid 126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 127 * @return the last matching email address 128 * @throws NoSuchEmailAddressException if a matching email address could not be found 129 */ 130 public EmailAddress findByUuid_Last(java.lang.String uuid, 131 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 132 throws com.liferay.portal.exception.NoSuchEmailAddressException; 133 134 /** 135 * Returns the last email address in the ordered set where uuid = ?. 136 * 137 * @param uuid the uuid 138 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 139 * @return the last matching email address, or <code>null</code> if a matching email address could not be found 140 */ 141 public EmailAddress fetchByUuid_Last(java.lang.String uuid, 142 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 143 144 /** 145 * Returns the email addresses before and after the current email address in the ordered set where uuid = ?. 146 * 147 * @param emailAddressId the primary key of the current email address 148 * @param uuid the uuid 149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 150 * @return the previous, current, and next email address 151 * @throws NoSuchEmailAddressException if a email address with the primary key could not be found 152 */ 153 public EmailAddress[] findByUuid_PrevAndNext(long emailAddressId, 154 java.lang.String uuid, 155 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 156 throws com.liferay.portal.exception.NoSuchEmailAddressException; 157 158 /** 159 * Removes all the email addresses where uuid = ? from the database. 160 * 161 * @param uuid the uuid 162 */ 163 public void removeByUuid(java.lang.String uuid); 164 165 /** 166 * Returns the number of email addresses where uuid = ?. 167 * 168 * @param uuid the uuid 169 * @return the number of matching email addresses 170 */ 171 public int countByUuid(java.lang.String uuid); 172 173 /** 174 * Returns all the email addresses where uuid = ? and companyId = ?. 175 * 176 * @param uuid the uuid 177 * @param companyId the company ID 178 * @return the matching email addresses 179 */ 180 public java.util.List<EmailAddress> findByUuid_C(java.lang.String uuid, 181 long companyId); 182 183 /** 184 * Returns a range of all the email addresses where uuid = ? and companyId = ?. 185 * 186 * <p> 187 * 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 EmailAddressModelImpl}. 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. 188 * </p> 189 * 190 * @param uuid the uuid 191 * @param companyId the company ID 192 * @param start the lower bound of the range of email addresses 193 * @param end the upper bound of the range of email addresses (not inclusive) 194 * @return the range of matching email addresses 195 */ 196 public java.util.List<EmailAddress> findByUuid_C(java.lang.String uuid, 197 long companyId, int start, int end); 198 199 /** 200 * Returns an ordered range of all the email addresses where uuid = ? and companyId = ?. 201 * 202 * <p> 203 * 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 EmailAddressModelImpl}. 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. 204 * </p> 205 * 206 * @param uuid the uuid 207 * @param companyId the company ID 208 * @param start the lower bound of the range of email addresses 209 * @param end the upper bound of the range of email addresses (not inclusive) 210 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 211 * @return the ordered range of matching email addresses 212 */ 213 public java.util.List<EmailAddress> findByUuid_C(java.lang.String uuid, 214 long companyId, int start, int end, 215 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 216 217 /** 218 * Returns an ordered range of all the email addresses where uuid = ? and companyId = ?. 219 * 220 * <p> 221 * 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 EmailAddressModelImpl}. 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. 222 * </p> 223 * 224 * @param uuid the uuid 225 * @param companyId the company ID 226 * @param start the lower bound of the range of email addresses 227 * @param end the upper bound of the range of email addresses (not inclusive) 228 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 229 * @param retrieveFromCache whether to retrieve from the finder cache 230 * @return the ordered range of matching email addresses 231 */ 232 public java.util.List<EmailAddress> findByUuid_C(java.lang.String uuid, 233 long companyId, int start, int end, 234 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator, 235 boolean retrieveFromCache); 236 237 /** 238 * Returns the first email address in the ordered set where uuid = ? and companyId = ?. 239 * 240 * @param uuid the uuid 241 * @param companyId the company ID 242 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 243 * @return the first matching email address 244 * @throws NoSuchEmailAddressException if a matching email address could not be found 245 */ 246 public EmailAddress findByUuid_C_First(java.lang.String uuid, 247 long companyId, 248 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 249 throws com.liferay.portal.exception.NoSuchEmailAddressException; 250 251 /** 252 * Returns the first email address in the ordered set where uuid = ? and companyId = ?. 253 * 254 * @param uuid the uuid 255 * @param companyId the company ID 256 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 257 * @return the first matching email address, or <code>null</code> if a matching email address could not be found 258 */ 259 public EmailAddress fetchByUuid_C_First(java.lang.String uuid, 260 long companyId, 261 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 262 263 /** 264 * Returns the last email address in the ordered set where uuid = ? and companyId = ?. 265 * 266 * @param uuid the uuid 267 * @param companyId the company ID 268 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 269 * @return the last matching email address 270 * @throws NoSuchEmailAddressException if a matching email address could not be found 271 */ 272 public EmailAddress findByUuid_C_Last(java.lang.String uuid, 273 long companyId, 274 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 275 throws com.liferay.portal.exception.NoSuchEmailAddressException; 276 277 /** 278 * Returns the last email address in the ordered set where uuid = ? and companyId = ?. 279 * 280 * @param uuid the uuid 281 * @param companyId the company ID 282 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 283 * @return the last matching email address, or <code>null</code> if a matching email address could not be found 284 */ 285 public EmailAddress fetchByUuid_C_Last(java.lang.String uuid, 286 long companyId, 287 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 288 289 /** 290 * Returns the email addresses before and after the current email address in the ordered set where uuid = ? and companyId = ?. 291 * 292 * @param emailAddressId the primary key of the current email address 293 * @param uuid the uuid 294 * @param companyId the company ID 295 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 296 * @return the previous, current, and next email address 297 * @throws NoSuchEmailAddressException if a email address with the primary key could not be found 298 */ 299 public EmailAddress[] findByUuid_C_PrevAndNext(long emailAddressId, 300 java.lang.String uuid, long companyId, 301 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 302 throws com.liferay.portal.exception.NoSuchEmailAddressException; 303 304 /** 305 * Removes all the email addresses where uuid = ? and companyId = ? from the database. 306 * 307 * @param uuid the uuid 308 * @param companyId the company ID 309 */ 310 public void removeByUuid_C(java.lang.String uuid, long companyId); 311 312 /** 313 * Returns the number of email addresses where uuid = ? and companyId = ?. 314 * 315 * @param uuid the uuid 316 * @param companyId the company ID 317 * @return the number of matching email addresses 318 */ 319 public int countByUuid_C(java.lang.String uuid, long companyId); 320 321 /** 322 * Returns all the email addresses where companyId = ?. 323 * 324 * @param companyId the company ID 325 * @return the matching email addresses 326 */ 327 public java.util.List<EmailAddress> findByCompanyId(long companyId); 328 329 /** 330 * Returns a range of all the email addresses where companyId = ?. 331 * 332 * <p> 333 * 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 EmailAddressModelImpl}. 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. 334 * </p> 335 * 336 * @param companyId the company ID 337 * @param start the lower bound of the range of email addresses 338 * @param end the upper bound of the range of email addresses (not inclusive) 339 * @return the range of matching email addresses 340 */ 341 public java.util.List<EmailAddress> findByCompanyId(long companyId, 342 int start, int end); 343 344 /** 345 * Returns an ordered range of all the email addresses where companyId = ?. 346 * 347 * <p> 348 * 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 EmailAddressModelImpl}. 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. 349 * </p> 350 * 351 * @param companyId the company ID 352 * @param start the lower bound of the range of email addresses 353 * @param end the upper bound of the range of email addresses (not inclusive) 354 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 355 * @return the ordered range of matching email addresses 356 */ 357 public java.util.List<EmailAddress> findByCompanyId(long companyId, 358 int start, int end, 359 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 360 361 /** 362 * Returns an ordered range of all the email addresses where companyId = ?. 363 * 364 * <p> 365 * 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 EmailAddressModelImpl}. 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. 366 * </p> 367 * 368 * @param companyId the company ID 369 * @param start the lower bound of the range of email addresses 370 * @param end the upper bound of the range of email addresses (not inclusive) 371 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 372 * @param retrieveFromCache whether to retrieve from the finder cache 373 * @return the ordered range of matching email addresses 374 */ 375 public java.util.List<EmailAddress> findByCompanyId(long companyId, 376 int start, int end, 377 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator, 378 boolean retrieveFromCache); 379 380 /** 381 * Returns the first email address in the ordered set where companyId = ?. 382 * 383 * @param companyId the company ID 384 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 385 * @return the first matching email address 386 * @throws NoSuchEmailAddressException if a matching email address could not be found 387 */ 388 public EmailAddress findByCompanyId_First(long companyId, 389 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 390 throws com.liferay.portal.exception.NoSuchEmailAddressException; 391 392 /** 393 * Returns the first email address in the ordered set where companyId = ?. 394 * 395 * @param companyId the company ID 396 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 397 * @return the first matching email address, or <code>null</code> if a matching email address could not be found 398 */ 399 public EmailAddress fetchByCompanyId_First(long companyId, 400 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 401 402 /** 403 * Returns the last email address in the ordered set where companyId = ?. 404 * 405 * @param companyId the company ID 406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 407 * @return the last matching email address 408 * @throws NoSuchEmailAddressException if a matching email address could not be found 409 */ 410 public EmailAddress findByCompanyId_Last(long companyId, 411 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 412 throws com.liferay.portal.exception.NoSuchEmailAddressException; 413 414 /** 415 * Returns the last email address in the ordered set where companyId = ?. 416 * 417 * @param companyId the company ID 418 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 419 * @return the last matching email address, or <code>null</code> if a matching email address could not be found 420 */ 421 public EmailAddress fetchByCompanyId_Last(long companyId, 422 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 423 424 /** 425 * Returns the email addresses before and after the current email address in the ordered set where companyId = ?. 426 * 427 * @param emailAddressId the primary key of the current email address 428 * @param companyId the company ID 429 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 430 * @return the previous, current, and next email address 431 * @throws NoSuchEmailAddressException if a email address with the primary key could not be found 432 */ 433 public EmailAddress[] findByCompanyId_PrevAndNext(long emailAddressId, 434 long companyId, 435 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 436 throws com.liferay.portal.exception.NoSuchEmailAddressException; 437 438 /** 439 * Removes all the email addresses where companyId = ? from the database. 440 * 441 * @param companyId the company ID 442 */ 443 public void removeByCompanyId(long companyId); 444 445 /** 446 * Returns the number of email addresses where companyId = ?. 447 * 448 * @param companyId the company ID 449 * @return the number of matching email addresses 450 */ 451 public int countByCompanyId(long companyId); 452 453 /** 454 * Returns all the email addresses where userId = ?. 455 * 456 * @param userId the user ID 457 * @return the matching email addresses 458 */ 459 public java.util.List<EmailAddress> findByUserId(long userId); 460 461 /** 462 * Returns a range of all the email addresses where userId = ?. 463 * 464 * <p> 465 * 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 EmailAddressModelImpl}. 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. 466 * </p> 467 * 468 * @param userId the user ID 469 * @param start the lower bound of the range of email addresses 470 * @param end the upper bound of the range of email addresses (not inclusive) 471 * @return the range of matching email addresses 472 */ 473 public java.util.List<EmailAddress> findByUserId(long userId, int start, 474 int end); 475 476 /** 477 * Returns an ordered range of all the email addresses where userId = ?. 478 * 479 * <p> 480 * 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 EmailAddressModelImpl}. 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. 481 * </p> 482 * 483 * @param userId the user ID 484 * @param start the lower bound of the range of email addresses 485 * @param end the upper bound of the range of email addresses (not inclusive) 486 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 487 * @return the ordered range of matching email addresses 488 */ 489 public java.util.List<EmailAddress> findByUserId(long userId, int start, 490 int end, 491 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 492 493 /** 494 * Returns an ordered range of all the email addresses where userId = ?. 495 * 496 * <p> 497 * 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 EmailAddressModelImpl}. 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. 498 * </p> 499 * 500 * @param userId the user ID 501 * @param start the lower bound of the range of email addresses 502 * @param end the upper bound of the range of email addresses (not inclusive) 503 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 504 * @param retrieveFromCache whether to retrieve from the finder cache 505 * @return the ordered range of matching email addresses 506 */ 507 public java.util.List<EmailAddress> findByUserId(long userId, int start, 508 int end, 509 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator, 510 boolean retrieveFromCache); 511 512 /** 513 * Returns the first email address in the ordered set where userId = ?. 514 * 515 * @param userId the user ID 516 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 517 * @return the first matching email address 518 * @throws NoSuchEmailAddressException if a matching email address could not be found 519 */ 520 public EmailAddress findByUserId_First(long userId, 521 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 522 throws com.liferay.portal.exception.NoSuchEmailAddressException; 523 524 /** 525 * Returns the first email address in the ordered set where userId = ?. 526 * 527 * @param userId the user ID 528 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 529 * @return the first matching email address, or <code>null</code> if a matching email address could not be found 530 */ 531 public EmailAddress fetchByUserId_First(long userId, 532 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 533 534 /** 535 * Returns the last email address in the ordered set where userId = ?. 536 * 537 * @param userId the user ID 538 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 539 * @return the last matching email address 540 * @throws NoSuchEmailAddressException if a matching email address could not be found 541 */ 542 public EmailAddress findByUserId_Last(long userId, 543 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 544 throws com.liferay.portal.exception.NoSuchEmailAddressException; 545 546 /** 547 * Returns the last email address in the ordered set where userId = ?. 548 * 549 * @param userId the user ID 550 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 551 * @return the last matching email address, or <code>null</code> if a matching email address could not be found 552 */ 553 public EmailAddress fetchByUserId_Last(long userId, 554 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 555 556 /** 557 * Returns the email addresses before and after the current email address in the ordered set where userId = ?. 558 * 559 * @param emailAddressId the primary key of the current email address 560 * @param userId the user ID 561 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 562 * @return the previous, current, and next email address 563 * @throws NoSuchEmailAddressException if a email address with the primary key could not be found 564 */ 565 public EmailAddress[] findByUserId_PrevAndNext(long emailAddressId, 566 long userId, 567 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 568 throws com.liferay.portal.exception.NoSuchEmailAddressException; 569 570 /** 571 * Removes all the email addresses where userId = ? from the database. 572 * 573 * @param userId the user ID 574 */ 575 public void removeByUserId(long userId); 576 577 /** 578 * Returns the number of email addresses where userId = ?. 579 * 580 * @param userId the user ID 581 * @return the number of matching email addresses 582 */ 583 public int countByUserId(long userId); 584 585 /** 586 * Returns all the email addresses where companyId = ? and classNameId = ?. 587 * 588 * @param companyId the company ID 589 * @param classNameId the class name ID 590 * @return the matching email addresses 591 */ 592 public java.util.List<EmailAddress> findByC_C(long companyId, 593 long classNameId); 594 595 /** 596 * Returns a range of all the email addresses where companyId = ? and classNameId = ?. 597 * 598 * <p> 599 * 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 EmailAddressModelImpl}. 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. 600 * </p> 601 * 602 * @param companyId the company ID 603 * @param classNameId the class name ID 604 * @param start the lower bound of the range of email addresses 605 * @param end the upper bound of the range of email addresses (not inclusive) 606 * @return the range of matching email addresses 607 */ 608 public java.util.List<EmailAddress> findByC_C(long companyId, 609 long classNameId, int start, int end); 610 611 /** 612 * Returns an ordered range of all the email addresses where companyId = ? and classNameId = ?. 613 * 614 * <p> 615 * 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 EmailAddressModelImpl}. 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. 616 * </p> 617 * 618 * @param companyId the company ID 619 * @param classNameId the class name ID 620 * @param start the lower bound of the range of email addresses 621 * @param end the upper bound of the range of email addresses (not inclusive) 622 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 623 * @return the ordered range of matching email addresses 624 */ 625 public java.util.List<EmailAddress> findByC_C(long companyId, 626 long classNameId, int start, int end, 627 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 628 629 /** 630 * Returns an ordered range of all the email addresses where companyId = ? and classNameId = ?. 631 * 632 * <p> 633 * 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 EmailAddressModelImpl}. 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. 634 * </p> 635 * 636 * @param companyId the company ID 637 * @param classNameId the class name ID 638 * @param start the lower bound of the range of email addresses 639 * @param end the upper bound of the range of email addresses (not inclusive) 640 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 641 * @param retrieveFromCache whether to retrieve from the finder cache 642 * @return the ordered range of matching email addresses 643 */ 644 public java.util.List<EmailAddress> findByC_C(long companyId, 645 long classNameId, int start, int end, 646 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator, 647 boolean retrieveFromCache); 648 649 /** 650 * Returns the first email address in the ordered set where companyId = ? and classNameId = ?. 651 * 652 * @param companyId the company ID 653 * @param classNameId the class name ID 654 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 655 * @return the first matching email address 656 * @throws NoSuchEmailAddressException if a matching email address could not be found 657 */ 658 public EmailAddress findByC_C_First(long companyId, long classNameId, 659 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 660 throws com.liferay.portal.exception.NoSuchEmailAddressException; 661 662 /** 663 * Returns the first email address in the ordered set where companyId = ? and classNameId = ?. 664 * 665 * @param companyId the company ID 666 * @param classNameId the class name ID 667 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 668 * @return the first matching email address, or <code>null</code> if a matching email address could not be found 669 */ 670 public EmailAddress fetchByC_C_First(long companyId, long classNameId, 671 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 672 673 /** 674 * Returns the last email address in the ordered set where companyId = ? and classNameId = ?. 675 * 676 * @param companyId the company ID 677 * @param classNameId the class name ID 678 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 679 * @return the last matching email address 680 * @throws NoSuchEmailAddressException if a matching email address could not be found 681 */ 682 public EmailAddress findByC_C_Last(long companyId, long classNameId, 683 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 684 throws com.liferay.portal.exception.NoSuchEmailAddressException; 685 686 /** 687 * Returns the last email address in the ordered set where companyId = ? and classNameId = ?. 688 * 689 * @param companyId the company ID 690 * @param classNameId the class name ID 691 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 692 * @return the last matching email address, or <code>null</code> if a matching email address could not be found 693 */ 694 public EmailAddress fetchByC_C_Last(long companyId, long classNameId, 695 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 696 697 /** 698 * Returns the email addresses before and after the current email address in the ordered set where companyId = ? and classNameId = ?. 699 * 700 * @param emailAddressId the primary key of the current email address 701 * @param companyId the company ID 702 * @param classNameId the class name ID 703 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 704 * @return the previous, current, and next email address 705 * @throws NoSuchEmailAddressException if a email address with the primary key could not be found 706 */ 707 public EmailAddress[] findByC_C_PrevAndNext(long emailAddressId, 708 long companyId, long classNameId, 709 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 710 throws com.liferay.portal.exception.NoSuchEmailAddressException; 711 712 /** 713 * Removes all the email addresses where companyId = ? and classNameId = ? from the database. 714 * 715 * @param companyId the company ID 716 * @param classNameId the class name ID 717 */ 718 public void removeByC_C(long companyId, long classNameId); 719 720 /** 721 * Returns the number of email addresses where companyId = ? and classNameId = ?. 722 * 723 * @param companyId the company ID 724 * @param classNameId the class name ID 725 * @return the number of matching email addresses 726 */ 727 public int countByC_C(long companyId, long classNameId); 728 729 /** 730 * Returns all the email addresses where companyId = ? and classNameId = ? and classPK = ?. 731 * 732 * @param companyId the company ID 733 * @param classNameId the class name ID 734 * @param classPK the class p k 735 * @return the matching email addresses 736 */ 737 public java.util.List<EmailAddress> findByC_C_C(long companyId, 738 long classNameId, long classPK); 739 740 /** 741 * Returns a range of all the email addresses where companyId = ? and classNameId = ? and classPK = ?. 742 * 743 * <p> 744 * 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 EmailAddressModelImpl}. 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. 745 * </p> 746 * 747 * @param companyId the company ID 748 * @param classNameId the class name ID 749 * @param classPK the class p k 750 * @param start the lower bound of the range of email addresses 751 * @param end the upper bound of the range of email addresses (not inclusive) 752 * @return the range of matching email addresses 753 */ 754 public java.util.List<EmailAddress> findByC_C_C(long companyId, 755 long classNameId, long classPK, int start, int end); 756 757 /** 758 * Returns an ordered range of all the email addresses where companyId = ? and classNameId = ? and classPK = ?. 759 * 760 * <p> 761 * 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 EmailAddressModelImpl}. 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. 762 * </p> 763 * 764 * @param companyId the company ID 765 * @param classNameId the class name ID 766 * @param classPK the class p k 767 * @param start the lower bound of the range of email addresses 768 * @param end the upper bound of the range of email addresses (not inclusive) 769 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 770 * @return the ordered range of matching email addresses 771 */ 772 public java.util.List<EmailAddress> findByC_C_C(long companyId, 773 long classNameId, long classPK, int start, int end, 774 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 775 776 /** 777 * Returns an ordered range of all the email addresses where companyId = ? and classNameId = ? and classPK = ?. 778 * 779 * <p> 780 * 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 EmailAddressModelImpl}. 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. 781 * </p> 782 * 783 * @param companyId the company ID 784 * @param classNameId the class name ID 785 * @param classPK the class p k 786 * @param start the lower bound of the range of email addresses 787 * @param end the upper bound of the range of email addresses (not inclusive) 788 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 789 * @param retrieveFromCache whether to retrieve from the finder cache 790 * @return the ordered range of matching email addresses 791 */ 792 public java.util.List<EmailAddress> findByC_C_C(long companyId, 793 long classNameId, long classPK, int start, int end, 794 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator, 795 boolean retrieveFromCache); 796 797 /** 798 * Returns the first email address in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 799 * 800 * @param companyId the company ID 801 * @param classNameId the class name ID 802 * @param classPK the class p k 803 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 804 * @return the first matching email address 805 * @throws NoSuchEmailAddressException if a matching email address could not be found 806 */ 807 public EmailAddress findByC_C_C_First(long companyId, long classNameId, 808 long classPK, 809 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 810 throws com.liferay.portal.exception.NoSuchEmailAddressException; 811 812 /** 813 * Returns the first email address in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 814 * 815 * @param companyId the company ID 816 * @param classNameId the class name ID 817 * @param classPK the class p k 818 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 819 * @return the first matching email address, or <code>null</code> if a matching email address could not be found 820 */ 821 public EmailAddress fetchByC_C_C_First(long companyId, long classNameId, 822 long classPK, 823 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 824 825 /** 826 * Returns the last email address in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 827 * 828 * @param companyId the company ID 829 * @param classNameId the class name ID 830 * @param classPK the class p k 831 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 832 * @return the last matching email address 833 * @throws NoSuchEmailAddressException if a matching email address could not be found 834 */ 835 public EmailAddress findByC_C_C_Last(long companyId, long classNameId, 836 long classPK, 837 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 838 throws com.liferay.portal.exception.NoSuchEmailAddressException; 839 840 /** 841 * Returns the last email address in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 842 * 843 * @param companyId the company ID 844 * @param classNameId the class name ID 845 * @param classPK the class p k 846 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 847 * @return the last matching email address, or <code>null</code> if a matching email address could not be found 848 */ 849 public EmailAddress fetchByC_C_C_Last(long companyId, long classNameId, 850 long classPK, 851 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 852 853 /** 854 * Returns the email addresses before and after the current email address in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 855 * 856 * @param emailAddressId the primary key of the current email address 857 * @param companyId the company ID 858 * @param classNameId the class name ID 859 * @param classPK the class p k 860 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 861 * @return the previous, current, and next email address 862 * @throws NoSuchEmailAddressException if a email address with the primary key could not be found 863 */ 864 public EmailAddress[] findByC_C_C_PrevAndNext(long emailAddressId, 865 long companyId, long classNameId, long classPK, 866 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 867 throws com.liferay.portal.exception.NoSuchEmailAddressException; 868 869 /** 870 * Removes all the email addresses where companyId = ? and classNameId = ? and classPK = ? from the database. 871 * 872 * @param companyId the company ID 873 * @param classNameId the class name ID 874 * @param classPK the class p k 875 */ 876 public void removeByC_C_C(long companyId, long classNameId, long classPK); 877 878 /** 879 * Returns the number of email addresses where companyId = ? and classNameId = ? and classPK = ?. 880 * 881 * @param companyId the company ID 882 * @param classNameId the class name ID 883 * @param classPK the class p k 884 * @return the number of matching email addresses 885 */ 886 public int countByC_C_C(long companyId, long classNameId, long classPK); 887 888 /** 889 * Returns all the email addresses where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 890 * 891 * @param companyId the company ID 892 * @param classNameId the class name ID 893 * @param classPK the class p k 894 * @param primary the primary 895 * @return the matching email addresses 896 */ 897 public java.util.List<EmailAddress> findByC_C_C_P(long companyId, 898 long classNameId, long classPK, boolean primary); 899 900 /** 901 * Returns a range of all the email addresses where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 902 * 903 * <p> 904 * 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 EmailAddressModelImpl}. 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. 905 * </p> 906 * 907 * @param companyId the company ID 908 * @param classNameId the class name ID 909 * @param classPK the class p k 910 * @param primary the primary 911 * @param start the lower bound of the range of email addresses 912 * @param end the upper bound of the range of email addresses (not inclusive) 913 * @return the range of matching email addresses 914 */ 915 public java.util.List<EmailAddress> findByC_C_C_P(long companyId, 916 long classNameId, long classPK, boolean primary, int start, int end); 917 918 /** 919 * Returns an ordered range of all the email addresses where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 920 * 921 * <p> 922 * 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 EmailAddressModelImpl}. 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. 923 * </p> 924 * 925 * @param companyId the company ID 926 * @param classNameId the class name ID 927 * @param classPK the class p k 928 * @param primary the primary 929 * @param start the lower bound of the range of email addresses 930 * @param end the upper bound of the range of email addresses (not inclusive) 931 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 932 * @return the ordered range of matching email addresses 933 */ 934 public java.util.List<EmailAddress> findByC_C_C_P(long companyId, 935 long classNameId, long classPK, boolean primary, int start, int end, 936 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 937 938 /** 939 * Returns an ordered range of all the email addresses where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 940 * 941 * <p> 942 * 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 EmailAddressModelImpl}. 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. 943 * </p> 944 * 945 * @param companyId the company ID 946 * @param classNameId the class name ID 947 * @param classPK the class p k 948 * @param primary the primary 949 * @param start the lower bound of the range of email addresses 950 * @param end the upper bound of the range of email addresses (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 email addresses 954 */ 955 public java.util.List<EmailAddress> findByC_C_C_P(long companyId, 956 long classNameId, long classPK, boolean primary, int start, int end, 957 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator, 958 boolean retrieveFromCache); 959 960 /** 961 * Returns the first email address in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 962 * 963 * @param companyId the company ID 964 * @param classNameId the class name ID 965 * @param classPK the class p k 966 * @param primary the primary 967 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 968 * @return the first matching email address 969 * @throws NoSuchEmailAddressException if a matching email address could not be found 970 */ 971 public EmailAddress findByC_C_C_P_First(long companyId, long classNameId, 972 long classPK, boolean primary, 973 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 974 throws com.liferay.portal.exception.NoSuchEmailAddressException; 975 976 /** 977 * Returns the first email address in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 978 * 979 * @param companyId the company ID 980 * @param classNameId the class name ID 981 * @param classPK the class p k 982 * @param primary the primary 983 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 984 * @return the first matching email address, or <code>null</code> if a matching email address could not be found 985 */ 986 public EmailAddress fetchByC_C_C_P_First(long companyId, long classNameId, 987 long classPK, boolean primary, 988 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 989 990 /** 991 * Returns the last email address in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 992 * 993 * @param companyId the company ID 994 * @param classNameId the class name ID 995 * @param classPK the class p k 996 * @param primary the primary 997 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 998 * @return the last matching email address 999 * @throws NoSuchEmailAddressException if a matching email address could not be found 1000 */ 1001 public EmailAddress findByC_C_C_P_Last(long companyId, long classNameId, 1002 long classPK, boolean primary, 1003 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 1004 throws com.liferay.portal.exception.NoSuchEmailAddressException; 1005 1006 /** 1007 * Returns the last email address in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1008 * 1009 * @param companyId the company ID 1010 * @param classNameId the class name ID 1011 * @param classPK the class p k 1012 * @param primary the primary 1013 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1014 * @return the last matching email address, or <code>null</code> if a matching email address could not be found 1015 */ 1016 public EmailAddress fetchByC_C_C_P_Last(long companyId, long classNameId, 1017 long classPK, boolean primary, 1018 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 1019 1020 /** 1021 * Returns the email addresses before and after the current email address in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1022 * 1023 * @param emailAddressId the primary key of the current email address 1024 * @param companyId the company ID 1025 * @param classNameId the class name ID 1026 * @param classPK the class p k 1027 * @param primary the primary 1028 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1029 * @return the previous, current, and next email address 1030 * @throws NoSuchEmailAddressException if a email address with the primary key could not be found 1031 */ 1032 public EmailAddress[] findByC_C_C_P_PrevAndNext(long emailAddressId, 1033 long companyId, long classNameId, long classPK, boolean primary, 1034 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator) 1035 throws com.liferay.portal.exception.NoSuchEmailAddressException; 1036 1037 /** 1038 * Removes all the email addresses where companyId = ? and classNameId = ? and classPK = ? and primary = ? from the database. 1039 * 1040 * @param companyId the company ID 1041 * @param classNameId the class name ID 1042 * @param classPK the class p k 1043 * @param primary the primary 1044 */ 1045 public void removeByC_C_C_P(long companyId, long classNameId, long classPK, 1046 boolean primary); 1047 1048 /** 1049 * Returns the number of email addresses where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1050 * 1051 * @param companyId the company ID 1052 * @param classNameId the class name ID 1053 * @param classPK the class p k 1054 * @param primary the primary 1055 * @return the number of matching email addresses 1056 */ 1057 public int countByC_C_C_P(long companyId, long classNameId, long classPK, 1058 boolean primary); 1059 1060 /** 1061 * Caches the email address in the entity cache if it is enabled. 1062 * 1063 * @param emailAddress the email address 1064 */ 1065 public void cacheResult(EmailAddress emailAddress); 1066 1067 /** 1068 * Caches the email addresses in the entity cache if it is enabled. 1069 * 1070 * @param emailAddresses the email addresses 1071 */ 1072 public void cacheResult(java.util.List<EmailAddress> emailAddresses); 1073 1074 /** 1075 * Creates a new email address with the primary key. Does not add the email address to the database. 1076 * 1077 * @param emailAddressId the primary key for the new email address 1078 * @return the new email address 1079 */ 1080 public EmailAddress create(long emailAddressId); 1081 1082 /** 1083 * Removes the email address with the primary key from the database. Also notifies the appropriate model listeners. 1084 * 1085 * @param emailAddressId the primary key of the email address 1086 * @return the email address that was removed 1087 * @throws NoSuchEmailAddressException if a email address with the primary key could not be found 1088 */ 1089 public EmailAddress remove(long emailAddressId) 1090 throws com.liferay.portal.exception.NoSuchEmailAddressException; 1091 1092 public EmailAddress updateImpl(EmailAddress emailAddress); 1093 1094 /** 1095 * Returns the email address with the primary key or throws a {@link NoSuchEmailAddressException} if it could not be found. 1096 * 1097 * @param emailAddressId the primary key of the email address 1098 * @return the email address 1099 * @throws NoSuchEmailAddressException if a email address with the primary key could not be found 1100 */ 1101 public EmailAddress findByPrimaryKey(long emailAddressId) 1102 throws com.liferay.portal.exception.NoSuchEmailAddressException; 1103 1104 /** 1105 * Returns the email address with the primary key or returns <code>null</code> if it could not be found. 1106 * 1107 * @param emailAddressId the primary key of the email address 1108 * @return the email address, or <code>null</code> if a email address with the primary key could not be found 1109 */ 1110 public EmailAddress fetchByPrimaryKey(long emailAddressId); 1111 1112 @Override 1113 public java.util.Map<java.io.Serializable, EmailAddress> fetchByPrimaryKeys( 1114 java.util.Set<java.io.Serializable> primaryKeys); 1115 1116 /** 1117 * Returns all the email addresses. 1118 * 1119 * @return the email addresses 1120 */ 1121 public java.util.List<EmailAddress> findAll(); 1122 1123 /** 1124 * Returns a range of all the email addresses. 1125 * 1126 * <p> 1127 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link EmailAddressModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1128 * </p> 1129 * 1130 * @param start the lower bound of the range of email addresses 1131 * @param end the upper bound of the range of email addresses (not inclusive) 1132 * @return the range of email addresses 1133 */ 1134 public java.util.List<EmailAddress> findAll(int start, int end); 1135 1136 /** 1137 * Returns an ordered range of all the email addresses. 1138 * 1139 * <p> 1140 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 EmailAddressModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1141 * </p> 1142 * 1143 * @param start the lower bound of the range of email addresses 1144 * @param end the upper bound of the range of email addresses (not inclusive) 1145 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1146 * @return the ordered range of email addresses 1147 */ 1148 public java.util.List<EmailAddress> findAll(int start, int end, 1149 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator); 1150 1151 /** 1152 * Returns an ordered range of all the email addresses. 1153 * 1154 * <p> 1155 * 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 EmailAddressModelImpl}. 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. 1156 * </p> 1157 * 1158 * @param start the lower bound of the range of email addresses 1159 * @param end the upper bound of the range of email addresses (not inclusive) 1160 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1161 * @param retrieveFromCache whether to retrieve from the finder cache 1162 * @return the ordered range of email addresses 1163 */ 1164 public java.util.List<EmailAddress> findAll(int start, int end, 1165 com.liferay.portal.kernel.util.OrderByComparator<EmailAddress> orderByComparator, 1166 boolean retrieveFromCache); 1167 1168 /** 1169 * Removes all the email addresses from the database. 1170 */ 1171 public void removeAll(); 1172 1173 /** 1174 * Returns the number of email addresses. 1175 * 1176 * @return the number of email addresses 1177 */ 1178 public int countAll(); 1179 1180 @Override 1181 public java.util.Set<java.lang.String> getBadColumnNames(); 1182 }