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