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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63; 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 = &#63; and companyId = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63; 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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63; 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 = &#63; and classNameId = &#63; and classPK = &#63; and mailing = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63; 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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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    }