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