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