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