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