1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.service.persistence;
24  
25  import com.liferay.portal.NoSuchEmailAddressException;
26  import com.liferay.portal.SystemException;
27  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
28  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
29  import com.liferay.portal.kernel.dao.orm.Query;
30  import com.liferay.portal.kernel.dao.orm.QueryPos;
31  import com.liferay.portal.kernel.dao.orm.QueryUtil;
32  import com.liferay.portal.kernel.dao.orm.Session;
33  import com.liferay.portal.kernel.util.GetterUtil;
34  import com.liferay.portal.kernel.util.ListUtil;
35  import com.liferay.portal.kernel.util.OrderByComparator;
36  import com.liferay.portal.kernel.util.StringPool;
37  import com.liferay.portal.kernel.util.StringUtil;
38  import com.liferay.portal.model.EmailAddress;
39  import com.liferay.portal.model.ModelListener;
40  import com.liferay.portal.model.impl.EmailAddressImpl;
41  import com.liferay.portal.model.impl.EmailAddressModelImpl;
42  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
43  
44  import org.apache.commons.logging.Log;
45  import org.apache.commons.logging.LogFactory;
46  
47  import java.util.ArrayList;
48  import java.util.Collections;
49  import java.util.Iterator;
50  import java.util.List;
51  
52  /**
53   * <a href="EmailAddressPersistenceImpl.java.html"><b><i>View Source</i></b></a>
54   *
55   * @author Brian Wing Shun Chan
56   *
57   */
58  public class EmailAddressPersistenceImpl extends BasePersistenceImpl
59      implements EmailAddressPersistence {
60      public EmailAddress create(long emailAddressId) {
61          EmailAddress emailAddress = new EmailAddressImpl();
62  
63          emailAddress.setNew(true);
64          emailAddress.setPrimaryKey(emailAddressId);
65  
66          return emailAddress;
67      }
68  
69      public EmailAddress remove(long emailAddressId)
70          throws NoSuchEmailAddressException, SystemException {
71          Session session = null;
72  
73          try {
74              session = openSession();
75  
76              EmailAddress emailAddress = (EmailAddress)session.get(EmailAddressImpl.class,
77                      new Long(emailAddressId));
78  
79              if (emailAddress == null) {
80                  if (_log.isWarnEnabled()) {
81                      _log.warn("No EmailAddress exists with the primary key " +
82                          emailAddressId);
83                  }
84  
85                  throw new NoSuchEmailAddressException(
86                      "No EmailAddress exists with the primary key " +
87                      emailAddressId);
88              }
89  
90              return remove(emailAddress);
91          }
92          catch (NoSuchEmailAddressException nsee) {
93              throw nsee;
94          }
95          catch (Exception e) {
96              throw processException(e);
97          }
98          finally {
99              closeSession(session);
100         }
101     }
102 
103     public EmailAddress remove(EmailAddress emailAddress)
104         throws SystemException {
105         if (_listeners.length > 0) {
106             for (ModelListener listener : _listeners) {
107                 listener.onBeforeRemove(emailAddress);
108             }
109         }
110 
111         emailAddress = removeImpl(emailAddress);
112 
113         if (_listeners.length > 0) {
114             for (ModelListener listener : _listeners) {
115                 listener.onAfterRemove(emailAddress);
116             }
117         }
118 
119         return emailAddress;
120     }
121 
122     protected EmailAddress removeImpl(EmailAddress emailAddress)
123         throws SystemException {
124         Session session = null;
125 
126         try {
127             session = openSession();
128 
129             session.delete(emailAddress);
130 
131             session.flush();
132 
133             return emailAddress;
134         }
135         catch (Exception e) {
136             throw processException(e);
137         }
138         finally {
139             closeSession(session);
140 
141             FinderCacheUtil.clearCache(EmailAddress.class.getName());
142         }
143     }
144 
145     /**
146      * @deprecated Use <code>update(EmailAddress emailAddress, boolean merge)</code>.
147      */
148     public EmailAddress update(EmailAddress emailAddress)
149         throws SystemException {
150         if (_log.isWarnEnabled()) {
151             _log.warn(
152                 "Using the deprecated update(EmailAddress emailAddress) method. Use update(EmailAddress emailAddress, boolean merge) instead.");
153         }
154 
155         return update(emailAddress, false);
156     }
157 
158     /**
159      * Add, update, or merge, the entity. This method also calls the model
160      * listeners to trigger the proper events associated with adding, deleting,
161      * or updating an entity.
162      *
163      * @param        emailAddress the entity to add, update, or merge
164      * @param        merge boolean value for whether to merge the entity. The
165      *                default value is false. Setting merge to true is more
166      *                expensive and should only be true when emailAddress is
167      *                transient. See LEP-5473 for a detailed discussion of this
168      *                method.
169      * @return        true if the portlet can be displayed via Ajax
170      */
171     public EmailAddress update(EmailAddress emailAddress, boolean merge)
172         throws SystemException {
173         boolean isNew = emailAddress.isNew();
174 
175         if (_listeners.length > 0) {
176             for (ModelListener listener : _listeners) {
177                 if (isNew) {
178                     listener.onBeforeCreate(emailAddress);
179                 }
180                 else {
181                     listener.onBeforeUpdate(emailAddress);
182                 }
183             }
184         }
185 
186         emailAddress = updateImpl(emailAddress, merge);
187 
188         if (_listeners.length > 0) {
189             for (ModelListener listener : _listeners) {
190                 if (isNew) {
191                     listener.onAfterCreate(emailAddress);
192                 }
193                 else {
194                     listener.onAfterUpdate(emailAddress);
195                 }
196             }
197         }
198 
199         return emailAddress;
200     }
201 
202     public EmailAddress updateImpl(
203         com.liferay.portal.model.EmailAddress emailAddress, boolean merge)
204         throws SystemException {
205         Session session = null;
206 
207         try {
208             session = openSession();
209 
210             if (merge) {
211                 session.merge(emailAddress);
212             }
213             else {
214                 if (emailAddress.isNew()) {
215                     session.save(emailAddress);
216                 }
217             }
218 
219             session.flush();
220 
221             emailAddress.setNew(false);
222 
223             return emailAddress;
224         }
225         catch (Exception e) {
226             throw processException(e);
227         }
228         finally {
229             closeSession(session);
230 
231             FinderCacheUtil.clearCache(EmailAddress.class.getName());
232         }
233     }
234 
235     public EmailAddress findByPrimaryKey(long emailAddressId)
236         throws NoSuchEmailAddressException, SystemException {
237         EmailAddress emailAddress = fetchByPrimaryKey(emailAddressId);
238 
239         if (emailAddress == null) {
240             if (_log.isWarnEnabled()) {
241                 _log.warn("No EmailAddress exists with the primary key " +
242                     emailAddressId);
243             }
244 
245             throw new NoSuchEmailAddressException(
246                 "No EmailAddress exists with the primary key " +
247                 emailAddressId);
248         }
249 
250         return emailAddress;
251     }
252 
253     public EmailAddress fetchByPrimaryKey(long emailAddressId)
254         throws SystemException {
255         Session session = null;
256 
257         try {
258             session = openSession();
259 
260             return (EmailAddress)session.get(EmailAddressImpl.class,
261                 new Long(emailAddressId));
262         }
263         catch (Exception e) {
264             throw processException(e);
265         }
266         finally {
267             closeSession(session);
268         }
269     }
270 
271     public List<EmailAddress> findByCompanyId(long companyId)
272         throws SystemException {
273         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
274         String finderClassName = EmailAddress.class.getName();
275         String finderMethodName = "findByCompanyId";
276         String[] finderParams = new String[] { Long.class.getName() };
277         Object[] finderArgs = new Object[] { new Long(companyId) };
278 
279         Object result = null;
280 
281         if (finderClassNameCacheEnabled) {
282             result = FinderCacheUtil.getResult(finderClassName,
283                     finderMethodName, finderParams, finderArgs, this);
284         }
285 
286         if (result == null) {
287             Session session = null;
288 
289             try {
290                 session = openSession();
291 
292                 StringBuilder query = new StringBuilder();
293 
294                 query.append(
295                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
296 
297                 query.append("companyId = ?");
298 
299                 query.append(" ");
300 
301                 query.append("ORDER BY ");
302 
303                 query.append("createDate ASC");
304 
305                 Query q = session.createQuery(query.toString());
306 
307                 QueryPos qPos = QueryPos.getInstance(q);
308 
309                 qPos.add(companyId);
310 
311                 List<EmailAddress> list = q.list();
312 
313                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
314                     finderClassName, finderMethodName, finderParams,
315                     finderArgs, list);
316 
317                 return list;
318             }
319             catch (Exception e) {
320                 throw processException(e);
321             }
322             finally {
323                 closeSession(session);
324             }
325         }
326         else {
327             return (List<EmailAddress>)result;
328         }
329     }
330 
331     public List<EmailAddress> findByCompanyId(long companyId, int start, int end)
332         throws SystemException {
333         return findByCompanyId(companyId, start, end, null);
334     }
335 
336     public List<EmailAddress> findByCompanyId(long companyId, int start,
337         int end, OrderByComparator obc) throws SystemException {
338         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
339         String finderClassName = EmailAddress.class.getName();
340         String finderMethodName = "findByCompanyId";
341         String[] finderParams = new String[] {
342                 Long.class.getName(),
343                 
344                 "java.lang.Integer", "java.lang.Integer",
345                 "com.liferay.portal.kernel.util.OrderByComparator"
346             };
347         Object[] finderArgs = new Object[] {
348                 new Long(companyId),
349                 
350                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
351             };
352 
353         Object result = null;
354 
355         if (finderClassNameCacheEnabled) {
356             result = FinderCacheUtil.getResult(finderClassName,
357                     finderMethodName, finderParams, finderArgs, this);
358         }
359 
360         if (result == null) {
361             Session session = null;
362 
363             try {
364                 session = openSession();
365 
366                 StringBuilder query = new StringBuilder();
367 
368                 query.append(
369                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
370 
371                 query.append("companyId = ?");
372 
373                 query.append(" ");
374 
375                 if (obc != null) {
376                     query.append("ORDER BY ");
377                     query.append(obc.getOrderBy());
378                 }
379 
380                 else {
381                     query.append("ORDER BY ");
382 
383                     query.append("createDate ASC");
384                 }
385 
386                 Query q = session.createQuery(query.toString());
387 
388                 QueryPos qPos = QueryPos.getInstance(q);
389 
390                 qPos.add(companyId);
391 
392                 List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
393                         getDialect(), start, end);
394 
395                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
396                     finderClassName, finderMethodName, finderParams,
397                     finderArgs, list);
398 
399                 return list;
400             }
401             catch (Exception e) {
402                 throw processException(e);
403             }
404             finally {
405                 closeSession(session);
406             }
407         }
408         else {
409             return (List<EmailAddress>)result;
410         }
411     }
412 
413     public EmailAddress findByCompanyId_First(long companyId,
414         OrderByComparator obc)
415         throws NoSuchEmailAddressException, SystemException {
416         List<EmailAddress> list = findByCompanyId(companyId, 0, 1, obc);
417 
418         if (list.size() == 0) {
419             StringBuilder msg = new StringBuilder();
420 
421             msg.append("No EmailAddress exists with the key {");
422 
423             msg.append("companyId=" + companyId);
424 
425             msg.append(StringPool.CLOSE_CURLY_BRACE);
426 
427             throw new NoSuchEmailAddressException(msg.toString());
428         }
429         else {
430             return list.get(0);
431         }
432     }
433 
434     public EmailAddress findByCompanyId_Last(long companyId,
435         OrderByComparator obc)
436         throws NoSuchEmailAddressException, SystemException {
437         int count = countByCompanyId(companyId);
438 
439         List<EmailAddress> list = findByCompanyId(companyId, count - 1, count,
440                 obc);
441 
442         if (list.size() == 0) {
443             StringBuilder msg = new StringBuilder();
444 
445             msg.append("No EmailAddress exists with the key {");
446 
447             msg.append("companyId=" + companyId);
448 
449             msg.append(StringPool.CLOSE_CURLY_BRACE);
450 
451             throw new NoSuchEmailAddressException(msg.toString());
452         }
453         else {
454             return list.get(0);
455         }
456     }
457 
458     public EmailAddress[] findByCompanyId_PrevAndNext(long emailAddressId,
459         long companyId, OrderByComparator obc)
460         throws NoSuchEmailAddressException, SystemException {
461         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
462 
463         int count = countByCompanyId(companyId);
464 
465         Session session = null;
466 
467         try {
468             session = openSession();
469 
470             StringBuilder query = new StringBuilder();
471 
472             query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
473 
474             query.append("companyId = ?");
475 
476             query.append(" ");
477 
478             if (obc != null) {
479                 query.append("ORDER BY ");
480                 query.append(obc.getOrderBy());
481             }
482 
483             else {
484                 query.append("ORDER BY ");
485 
486                 query.append("createDate ASC");
487             }
488 
489             Query q = session.createQuery(query.toString());
490 
491             QueryPos qPos = QueryPos.getInstance(q);
492 
493             qPos.add(companyId);
494 
495             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
496                     emailAddress);
497 
498             EmailAddress[] array = new EmailAddressImpl[3];
499 
500             array[0] = (EmailAddress)objArray[0];
501             array[1] = (EmailAddress)objArray[1];
502             array[2] = (EmailAddress)objArray[2];
503 
504             return array;
505         }
506         catch (Exception e) {
507             throw processException(e);
508         }
509         finally {
510             closeSession(session);
511         }
512     }
513 
514     public List<EmailAddress> findByUserId(long userId)
515         throws SystemException {
516         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
517         String finderClassName = EmailAddress.class.getName();
518         String finderMethodName = "findByUserId";
519         String[] finderParams = new String[] { Long.class.getName() };
520         Object[] finderArgs = new Object[] { new Long(userId) };
521 
522         Object result = null;
523 
524         if (finderClassNameCacheEnabled) {
525             result = FinderCacheUtil.getResult(finderClassName,
526                     finderMethodName, finderParams, finderArgs, this);
527         }
528 
529         if (result == null) {
530             Session session = null;
531 
532             try {
533                 session = openSession();
534 
535                 StringBuilder query = new StringBuilder();
536 
537                 query.append(
538                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
539 
540                 query.append("userId = ?");
541 
542                 query.append(" ");
543 
544                 query.append("ORDER BY ");
545 
546                 query.append("createDate ASC");
547 
548                 Query q = session.createQuery(query.toString());
549 
550                 QueryPos qPos = QueryPos.getInstance(q);
551 
552                 qPos.add(userId);
553 
554                 List<EmailAddress> list = q.list();
555 
556                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
557                     finderClassName, finderMethodName, finderParams,
558                     finderArgs, list);
559 
560                 return list;
561             }
562             catch (Exception e) {
563                 throw processException(e);
564             }
565             finally {
566                 closeSession(session);
567             }
568         }
569         else {
570             return (List<EmailAddress>)result;
571         }
572     }
573 
574     public List<EmailAddress> findByUserId(long userId, int start, int end)
575         throws SystemException {
576         return findByUserId(userId, start, end, null);
577     }
578 
579     public List<EmailAddress> findByUserId(long userId, int start, int end,
580         OrderByComparator obc) throws SystemException {
581         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
582         String finderClassName = EmailAddress.class.getName();
583         String finderMethodName = "findByUserId";
584         String[] finderParams = new String[] {
585                 Long.class.getName(),
586                 
587                 "java.lang.Integer", "java.lang.Integer",
588                 "com.liferay.portal.kernel.util.OrderByComparator"
589             };
590         Object[] finderArgs = new Object[] {
591                 new Long(userId),
592                 
593                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
594             };
595 
596         Object result = null;
597 
598         if (finderClassNameCacheEnabled) {
599             result = FinderCacheUtil.getResult(finderClassName,
600                     finderMethodName, finderParams, finderArgs, this);
601         }
602 
603         if (result == null) {
604             Session session = null;
605 
606             try {
607                 session = openSession();
608 
609                 StringBuilder query = new StringBuilder();
610 
611                 query.append(
612                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
613 
614                 query.append("userId = ?");
615 
616                 query.append(" ");
617 
618                 if (obc != null) {
619                     query.append("ORDER BY ");
620                     query.append(obc.getOrderBy());
621                 }
622 
623                 else {
624                     query.append("ORDER BY ");
625 
626                     query.append("createDate ASC");
627                 }
628 
629                 Query q = session.createQuery(query.toString());
630 
631                 QueryPos qPos = QueryPos.getInstance(q);
632 
633                 qPos.add(userId);
634 
635                 List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
636                         getDialect(), start, end);
637 
638                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
639                     finderClassName, finderMethodName, finderParams,
640                     finderArgs, list);
641 
642                 return list;
643             }
644             catch (Exception e) {
645                 throw processException(e);
646             }
647             finally {
648                 closeSession(session);
649             }
650         }
651         else {
652             return (List<EmailAddress>)result;
653         }
654     }
655 
656     public EmailAddress findByUserId_First(long userId, OrderByComparator obc)
657         throws NoSuchEmailAddressException, SystemException {
658         List<EmailAddress> list = findByUserId(userId, 0, 1, obc);
659 
660         if (list.size() == 0) {
661             StringBuilder msg = new StringBuilder();
662 
663             msg.append("No EmailAddress exists with the key {");
664 
665             msg.append("userId=" + userId);
666 
667             msg.append(StringPool.CLOSE_CURLY_BRACE);
668 
669             throw new NoSuchEmailAddressException(msg.toString());
670         }
671         else {
672             return list.get(0);
673         }
674     }
675 
676     public EmailAddress findByUserId_Last(long userId, OrderByComparator obc)
677         throws NoSuchEmailAddressException, SystemException {
678         int count = countByUserId(userId);
679 
680         List<EmailAddress> list = findByUserId(userId, count - 1, count, obc);
681 
682         if (list.size() == 0) {
683             StringBuilder msg = new StringBuilder();
684 
685             msg.append("No EmailAddress exists with the key {");
686 
687             msg.append("userId=" + userId);
688 
689             msg.append(StringPool.CLOSE_CURLY_BRACE);
690 
691             throw new NoSuchEmailAddressException(msg.toString());
692         }
693         else {
694             return list.get(0);
695         }
696     }
697 
698     public EmailAddress[] findByUserId_PrevAndNext(long emailAddressId,
699         long userId, OrderByComparator obc)
700         throws NoSuchEmailAddressException, SystemException {
701         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
702 
703         int count = countByUserId(userId);
704 
705         Session session = null;
706 
707         try {
708             session = openSession();
709 
710             StringBuilder query = new StringBuilder();
711 
712             query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
713 
714             query.append("userId = ?");
715 
716             query.append(" ");
717 
718             if (obc != null) {
719                 query.append("ORDER BY ");
720                 query.append(obc.getOrderBy());
721             }
722 
723             else {
724                 query.append("ORDER BY ");
725 
726                 query.append("createDate ASC");
727             }
728 
729             Query q = session.createQuery(query.toString());
730 
731             QueryPos qPos = QueryPos.getInstance(q);
732 
733             qPos.add(userId);
734 
735             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
736                     emailAddress);
737 
738             EmailAddress[] array = new EmailAddressImpl[3];
739 
740             array[0] = (EmailAddress)objArray[0];
741             array[1] = (EmailAddress)objArray[1];
742             array[2] = (EmailAddress)objArray[2];
743 
744             return array;
745         }
746         catch (Exception e) {
747             throw processException(e);
748         }
749         finally {
750             closeSession(session);
751         }
752     }
753 
754     public List<EmailAddress> findByC_C(long companyId, long classNameId)
755         throws SystemException {
756         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
757         String finderClassName = EmailAddress.class.getName();
758         String finderMethodName = "findByC_C";
759         String[] finderParams = new String[] {
760                 Long.class.getName(), Long.class.getName()
761             };
762         Object[] finderArgs = new Object[] {
763                 new Long(companyId), new Long(classNameId)
764             };
765 
766         Object result = null;
767 
768         if (finderClassNameCacheEnabled) {
769             result = FinderCacheUtil.getResult(finderClassName,
770                     finderMethodName, finderParams, finderArgs, this);
771         }
772 
773         if (result == null) {
774             Session session = null;
775 
776             try {
777                 session = openSession();
778 
779                 StringBuilder query = new StringBuilder();
780 
781                 query.append(
782                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
783 
784                 query.append("companyId = ?");
785 
786                 query.append(" AND ");
787 
788                 query.append("classNameId = ?");
789 
790                 query.append(" ");
791 
792                 query.append("ORDER BY ");
793 
794                 query.append("createDate ASC");
795 
796                 Query q = session.createQuery(query.toString());
797 
798                 QueryPos qPos = QueryPos.getInstance(q);
799 
800                 qPos.add(companyId);
801 
802                 qPos.add(classNameId);
803 
804                 List<EmailAddress> list = q.list();
805 
806                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
807                     finderClassName, finderMethodName, finderParams,
808                     finderArgs, list);
809 
810                 return list;
811             }
812             catch (Exception e) {
813                 throw processException(e);
814             }
815             finally {
816                 closeSession(session);
817             }
818         }
819         else {
820             return (List<EmailAddress>)result;
821         }
822     }
823 
824     public List<EmailAddress> findByC_C(long companyId, long classNameId,
825         int start, int end) throws SystemException {
826         return findByC_C(companyId, classNameId, start, end, null);
827     }
828 
829     public List<EmailAddress> findByC_C(long companyId, long classNameId,
830         int start, int end, OrderByComparator obc) throws SystemException {
831         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
832         String finderClassName = EmailAddress.class.getName();
833         String finderMethodName = "findByC_C";
834         String[] finderParams = new String[] {
835                 Long.class.getName(), Long.class.getName(),
836                 
837                 "java.lang.Integer", "java.lang.Integer",
838                 "com.liferay.portal.kernel.util.OrderByComparator"
839             };
840         Object[] finderArgs = new Object[] {
841                 new Long(companyId), new Long(classNameId),
842                 
843                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
844             };
845 
846         Object result = null;
847 
848         if (finderClassNameCacheEnabled) {
849             result = FinderCacheUtil.getResult(finderClassName,
850                     finderMethodName, finderParams, finderArgs, this);
851         }
852 
853         if (result == null) {
854             Session session = null;
855 
856             try {
857                 session = openSession();
858 
859                 StringBuilder query = new StringBuilder();
860 
861                 query.append(
862                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
863 
864                 query.append("companyId = ?");
865 
866                 query.append(" AND ");
867 
868                 query.append("classNameId = ?");
869 
870                 query.append(" ");
871 
872                 if (obc != null) {
873                     query.append("ORDER BY ");
874                     query.append(obc.getOrderBy());
875                 }
876 
877                 else {
878                     query.append("ORDER BY ");
879 
880                     query.append("createDate ASC");
881                 }
882 
883                 Query q = session.createQuery(query.toString());
884 
885                 QueryPos qPos = QueryPos.getInstance(q);
886 
887                 qPos.add(companyId);
888 
889                 qPos.add(classNameId);
890 
891                 List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
892                         getDialect(), start, end);
893 
894                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
895                     finderClassName, finderMethodName, finderParams,
896                     finderArgs, list);
897 
898                 return list;
899             }
900             catch (Exception e) {
901                 throw processException(e);
902             }
903             finally {
904                 closeSession(session);
905             }
906         }
907         else {
908             return (List<EmailAddress>)result;
909         }
910     }
911 
912     public EmailAddress findByC_C_First(long companyId, long classNameId,
913         OrderByComparator obc)
914         throws NoSuchEmailAddressException, SystemException {
915         List<EmailAddress> list = findByC_C(companyId, classNameId, 0, 1, obc);
916 
917         if (list.size() == 0) {
918             StringBuilder msg = new StringBuilder();
919 
920             msg.append("No EmailAddress exists with the key {");
921 
922             msg.append("companyId=" + companyId);
923 
924             msg.append(", ");
925             msg.append("classNameId=" + classNameId);
926 
927             msg.append(StringPool.CLOSE_CURLY_BRACE);
928 
929             throw new NoSuchEmailAddressException(msg.toString());
930         }
931         else {
932             return list.get(0);
933         }
934     }
935 
936     public EmailAddress findByC_C_Last(long companyId, long classNameId,
937         OrderByComparator obc)
938         throws NoSuchEmailAddressException, SystemException {
939         int count = countByC_C(companyId, classNameId);
940 
941         List<EmailAddress> list = findByC_C(companyId, classNameId, count - 1,
942                 count, obc);
943 
944         if (list.size() == 0) {
945             StringBuilder msg = new StringBuilder();
946 
947             msg.append("No EmailAddress exists with the key {");
948 
949             msg.append("companyId=" + companyId);
950 
951             msg.append(", ");
952             msg.append("classNameId=" + classNameId);
953 
954             msg.append(StringPool.CLOSE_CURLY_BRACE);
955 
956             throw new NoSuchEmailAddressException(msg.toString());
957         }
958         else {
959             return list.get(0);
960         }
961     }
962 
963     public EmailAddress[] findByC_C_PrevAndNext(long emailAddressId,
964         long companyId, long classNameId, OrderByComparator obc)
965         throws NoSuchEmailAddressException, SystemException {
966         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
967 
968         int count = countByC_C(companyId, classNameId);
969 
970         Session session = null;
971 
972         try {
973             session = openSession();
974 
975             StringBuilder query = new StringBuilder();
976 
977             query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
978 
979             query.append("companyId = ?");
980 
981             query.append(" AND ");
982 
983             query.append("classNameId = ?");
984 
985             query.append(" ");
986 
987             if (obc != null) {
988                 query.append("ORDER BY ");
989                 query.append(obc.getOrderBy());
990             }
991 
992             else {
993                 query.append("ORDER BY ");
994 
995                 query.append("createDate ASC");
996             }
997 
998             Query q = session.createQuery(query.toString());
999 
1000            QueryPos qPos = QueryPos.getInstance(q);
1001
1002            qPos.add(companyId);
1003
1004            qPos.add(classNameId);
1005
1006            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1007                    emailAddress);
1008
1009            EmailAddress[] array = new EmailAddressImpl[3];
1010
1011            array[0] = (EmailAddress)objArray[0];
1012            array[1] = (EmailAddress)objArray[1];
1013            array[2] = (EmailAddress)objArray[2];
1014
1015            return array;
1016        }
1017        catch (Exception e) {
1018            throw processException(e);
1019        }
1020        finally {
1021            closeSession(session);
1022        }
1023    }
1024
1025    public List<EmailAddress> findByC_C_C(long companyId, long classNameId,
1026        long classPK) throws SystemException {
1027        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1028        String finderClassName = EmailAddress.class.getName();
1029        String finderMethodName = "findByC_C_C";
1030        String[] finderParams = new String[] {
1031                Long.class.getName(), Long.class.getName(), Long.class.getName()
1032            };
1033        Object[] finderArgs = new Object[] {
1034                new Long(companyId), new Long(classNameId), new Long(classPK)
1035            };
1036
1037        Object result = null;
1038
1039        if (finderClassNameCacheEnabled) {
1040            result = FinderCacheUtil.getResult(finderClassName,
1041                    finderMethodName, finderParams, finderArgs, this);
1042        }
1043
1044        if (result == null) {
1045            Session session = null;
1046
1047            try {
1048                session = openSession();
1049
1050                StringBuilder query = new StringBuilder();
1051
1052                query.append(
1053                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1054
1055                query.append("companyId = ?");
1056
1057                query.append(" AND ");
1058
1059                query.append("classNameId = ?");
1060
1061                query.append(" AND ");
1062
1063                query.append("classPK = ?");
1064
1065                query.append(" ");
1066
1067                query.append("ORDER BY ");
1068
1069                query.append("createDate ASC");
1070
1071                Query q = session.createQuery(query.toString());
1072
1073                QueryPos qPos = QueryPos.getInstance(q);
1074
1075                qPos.add(companyId);
1076
1077                qPos.add(classNameId);
1078
1079                qPos.add(classPK);
1080
1081                List<EmailAddress> list = q.list();
1082
1083                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1084                    finderClassName, finderMethodName, finderParams,
1085                    finderArgs, list);
1086
1087                return list;
1088            }
1089            catch (Exception e) {
1090                throw processException(e);
1091            }
1092            finally {
1093                closeSession(session);
1094            }
1095        }
1096        else {
1097            return (List<EmailAddress>)result;
1098        }
1099    }
1100
1101    public List<EmailAddress> findByC_C_C(long companyId, long classNameId,
1102        long classPK, int start, int end) throws SystemException {
1103        return findByC_C_C(companyId, classNameId, classPK, start, end, null);
1104    }
1105
1106    public List<EmailAddress> findByC_C_C(long companyId, long classNameId,
1107        long classPK, int start, int end, OrderByComparator obc)
1108        throws SystemException {
1109        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1110        String finderClassName = EmailAddress.class.getName();
1111        String finderMethodName = "findByC_C_C";
1112        String[] finderParams = new String[] {
1113                Long.class.getName(), Long.class.getName(), Long.class.getName(),
1114                
1115                "java.lang.Integer", "java.lang.Integer",
1116                "com.liferay.portal.kernel.util.OrderByComparator"
1117            };
1118        Object[] finderArgs = new Object[] {
1119                new Long(companyId), new Long(classNameId), new Long(classPK),
1120                
1121                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1122            };
1123
1124        Object result = null;
1125
1126        if (finderClassNameCacheEnabled) {
1127            result = FinderCacheUtil.getResult(finderClassName,
1128                    finderMethodName, finderParams, finderArgs, this);
1129        }
1130
1131        if (result == null) {
1132            Session session = null;
1133
1134            try {
1135                session = openSession();
1136
1137                StringBuilder query = new StringBuilder();
1138
1139                query.append(
1140                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1141
1142                query.append("companyId = ?");
1143
1144                query.append(" AND ");
1145
1146                query.append("classNameId = ?");
1147
1148                query.append(" AND ");
1149
1150                query.append("classPK = ?");
1151
1152                query.append(" ");
1153
1154                if (obc != null) {
1155                    query.append("ORDER BY ");
1156                    query.append(obc.getOrderBy());
1157                }
1158
1159                else {
1160                    query.append("ORDER BY ");
1161
1162                    query.append("createDate ASC");
1163                }
1164
1165                Query q = session.createQuery(query.toString());
1166
1167                QueryPos qPos = QueryPos.getInstance(q);
1168
1169                qPos.add(companyId);
1170
1171                qPos.add(classNameId);
1172
1173                qPos.add(classPK);
1174
1175                List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
1176                        getDialect(), start, end);
1177
1178                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1179                    finderClassName, finderMethodName, finderParams,
1180                    finderArgs, list);
1181
1182                return list;
1183            }
1184            catch (Exception e) {
1185                throw processException(e);
1186            }
1187            finally {
1188                closeSession(session);
1189            }
1190        }
1191        else {
1192            return (List<EmailAddress>)result;
1193        }
1194    }
1195
1196    public EmailAddress findByC_C_C_First(long companyId, long classNameId,
1197        long classPK, OrderByComparator obc)
1198        throws NoSuchEmailAddressException, SystemException {
1199        List<EmailAddress> list = findByC_C_C(companyId, classNameId, classPK,
1200                0, 1, obc);
1201
1202        if (list.size() == 0) {
1203            StringBuilder msg = new StringBuilder();
1204
1205            msg.append("No EmailAddress exists with the key {");
1206
1207            msg.append("companyId=" + companyId);
1208
1209            msg.append(", ");
1210            msg.append("classNameId=" + classNameId);
1211
1212            msg.append(", ");
1213            msg.append("classPK=" + classPK);
1214
1215            msg.append(StringPool.CLOSE_CURLY_BRACE);
1216
1217            throw new NoSuchEmailAddressException(msg.toString());
1218        }
1219        else {
1220            return list.get(0);
1221        }
1222    }
1223
1224    public EmailAddress findByC_C_C_Last(long companyId, long classNameId,
1225        long classPK, OrderByComparator obc)
1226        throws NoSuchEmailAddressException, SystemException {
1227        int count = countByC_C_C(companyId, classNameId, classPK);
1228
1229        List<EmailAddress> list = findByC_C_C(companyId, classNameId, classPK,
1230                count - 1, count, obc);
1231
1232        if (list.size() == 0) {
1233            StringBuilder msg = new StringBuilder();
1234
1235            msg.append("No EmailAddress exists with the key {");
1236
1237            msg.append("companyId=" + companyId);
1238
1239            msg.append(", ");
1240            msg.append("classNameId=" + classNameId);
1241
1242            msg.append(", ");
1243            msg.append("classPK=" + classPK);
1244
1245            msg.append(StringPool.CLOSE_CURLY_BRACE);
1246
1247            throw new NoSuchEmailAddressException(msg.toString());
1248        }
1249        else {
1250            return list.get(0);
1251        }
1252    }
1253
1254    public EmailAddress[] findByC_C_C_PrevAndNext(long emailAddressId,
1255        long companyId, long classNameId, long classPK, OrderByComparator obc)
1256        throws NoSuchEmailAddressException, SystemException {
1257        EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
1258
1259        int count = countByC_C_C(companyId, classNameId, classPK);
1260
1261        Session session = null;
1262
1263        try {
1264            session = openSession();
1265
1266            StringBuilder query = new StringBuilder();
1267
1268            query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
1269
1270            query.append("companyId = ?");
1271
1272            query.append(" AND ");
1273
1274            query.append("classNameId = ?");
1275
1276            query.append(" AND ");
1277
1278            query.append("classPK = ?");
1279
1280            query.append(" ");
1281
1282            if (obc != null) {
1283                query.append("ORDER BY ");
1284                query.append(obc.getOrderBy());
1285            }
1286
1287            else {
1288                query.append("ORDER BY ");
1289
1290                query.append("createDate ASC");
1291            }
1292
1293            Query q = session.createQuery(query.toString());
1294
1295            QueryPos qPos = QueryPos.getInstance(q);
1296
1297            qPos.add(companyId);
1298
1299            qPos.add(classNameId);
1300
1301            qPos.add(classPK);
1302
1303            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1304                    emailAddress);
1305
1306            EmailAddress[] array = new EmailAddressImpl[3];
1307
1308            array[0] = (EmailAddress)objArray[0];
1309            array[1] = (EmailAddress)objArray[1];
1310            array[2] = (EmailAddress)objArray[2];
1311
1312            return array;
1313        }
1314        catch (Exception e) {
1315            throw processException(e);
1316        }
1317        finally {
1318            closeSession(session);
1319        }
1320    }
1321
1322    public List<EmailAddress> findByC_C_C_P(long companyId, long classNameId,
1323        long classPK, boolean primary) throws SystemException {
1324        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1325        String finderClassName = EmailAddress.class.getName();
1326        String finderMethodName = "findByC_C_C_P";
1327        String[] finderParams = new String[] {
1328                Long.class.getName(), Long.class.getName(), Long.class.getName(),
1329                Boolean.class.getName()
1330            };
1331        Object[] finderArgs = new Object[] {
1332                new Long(companyId), new Long(classNameId), new Long(classPK),
1333                Boolean.valueOf(primary)
1334            };
1335
1336        Object result = null;
1337
1338        if (finderClassNameCacheEnabled) {
1339            result = FinderCacheUtil.getResult(finderClassName,
1340                    finderMethodName, finderParams, finderArgs, this);
1341        }
1342
1343        if (result == null) {
1344            Session session = null;
1345
1346            try {
1347                session = openSession();
1348
1349                StringBuilder query = new StringBuilder();
1350
1351                query.append(
1352                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1353
1354                query.append("companyId = ?");
1355
1356                query.append(" AND ");
1357
1358                query.append("classNameId = ?");
1359
1360                query.append(" AND ");
1361
1362                query.append("classPK = ?");
1363
1364                query.append(" AND ");
1365
1366                query.append("primary_ = ?");
1367
1368                query.append(" ");
1369
1370                query.append("ORDER BY ");
1371
1372                query.append("createDate ASC");
1373
1374                Query q = session.createQuery(query.toString());
1375
1376                QueryPos qPos = QueryPos.getInstance(q);
1377
1378                qPos.add(companyId);
1379
1380                qPos.add(classNameId);
1381
1382                qPos.add(classPK);
1383
1384                qPos.add(primary);
1385
1386                List<EmailAddress> list = q.list();
1387
1388                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1389                    finderClassName, finderMethodName, finderParams,
1390                    finderArgs, list);
1391
1392                return list;
1393            }
1394            catch (Exception e) {
1395                throw processException(e);
1396            }
1397            finally {
1398                closeSession(session);
1399            }
1400        }
1401        else {
1402            return (List<EmailAddress>)result;
1403        }
1404    }
1405
1406    public List<EmailAddress> findByC_C_C_P(long companyId, long classNameId,
1407        long classPK, boolean primary, int start, int end)
1408        throws SystemException {
1409        return findByC_C_C_P(companyId, classNameId, classPK, primary, start,
1410            end, null);
1411    }
1412
1413    public List<EmailAddress> findByC_C_C_P(long companyId, long classNameId,
1414        long classPK, boolean primary, int start, int end, OrderByComparator obc)
1415        throws SystemException {
1416        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1417        String finderClassName = EmailAddress.class.getName();
1418        String finderMethodName = "findByC_C_C_P";
1419        String[] finderParams = new String[] {
1420                Long.class.getName(), Long.class.getName(), Long.class.getName(),
1421                Boolean.class.getName(),
1422                
1423                "java.lang.Integer", "java.lang.Integer",
1424                "com.liferay.portal.kernel.util.OrderByComparator"
1425            };
1426        Object[] finderArgs = new Object[] {
1427                new Long(companyId), new Long(classNameId), new Long(classPK),
1428                Boolean.valueOf(primary),
1429                
1430                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1431            };
1432
1433        Object result = null;
1434
1435        if (finderClassNameCacheEnabled) {
1436            result = FinderCacheUtil.getResult(finderClassName,
1437                    finderMethodName, finderParams, finderArgs, this);
1438        }
1439
1440        if (result == null) {
1441            Session session = null;
1442
1443            try {
1444                session = openSession();
1445
1446                StringBuilder query = new StringBuilder();
1447
1448                query.append(
1449                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1450
1451                query.append("companyId = ?");
1452
1453                query.append(" AND ");
1454
1455                query.append("classNameId = ?");
1456
1457                query.append(" AND ");
1458
1459                query.append("classPK = ?");
1460
1461                query.append(" AND ");
1462
1463                query.append("primary_ = ?");
1464
1465                query.append(" ");
1466
1467                if (obc != null) {
1468                    query.append("ORDER BY ");
1469                    query.append(obc.getOrderBy());
1470                }
1471
1472                else {
1473                    query.append("ORDER BY ");
1474
1475                    query.append("createDate ASC");
1476                }
1477
1478                Query q = session.createQuery(query.toString());
1479
1480                QueryPos qPos = QueryPos.getInstance(q);
1481
1482                qPos.add(companyId);
1483
1484                qPos.add(classNameId);
1485
1486                qPos.add(classPK);
1487
1488                qPos.add(primary);
1489
1490                List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
1491                        getDialect(), start, end);
1492
1493                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1494                    finderClassName, finderMethodName, finderParams,
1495                    finderArgs, list);
1496
1497                return list;
1498            }
1499            catch (Exception e) {
1500                throw processException(e);
1501            }
1502            finally {
1503                closeSession(session);
1504            }
1505        }
1506        else {
1507            return (List<EmailAddress>)result;
1508        }
1509    }
1510
1511    public EmailAddress findByC_C_C_P_First(long companyId, long classNameId,
1512        long classPK, boolean primary, OrderByComparator obc)
1513        throws NoSuchEmailAddressException, SystemException {
1514        List<EmailAddress> list = findByC_C_C_P(companyId, classNameId,
1515                classPK, primary, 0, 1, obc);
1516
1517        if (list.size() == 0) {
1518            StringBuilder msg = new StringBuilder();
1519
1520            msg.append("No EmailAddress exists with the key {");
1521
1522            msg.append("companyId=" + companyId);
1523
1524            msg.append(", ");
1525            msg.append("classNameId=" + classNameId);
1526
1527            msg.append(", ");
1528            msg.append("classPK=" + classPK);
1529
1530            msg.append(", ");
1531            msg.append("primary=" + primary);
1532
1533            msg.append(StringPool.CLOSE_CURLY_BRACE);
1534
1535            throw new NoSuchEmailAddressException(msg.toString());
1536        }
1537        else {
1538            return list.get(0);
1539        }
1540    }
1541
1542    public EmailAddress findByC_C_C_P_Last(long companyId, long classNameId,
1543        long classPK, boolean primary, OrderByComparator obc)
1544        throws NoSuchEmailAddressException, SystemException {
1545        int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1546
1547        List<EmailAddress> list = findByC_C_C_P(companyId, classNameId,
1548                classPK, primary, count - 1, count, obc);
1549
1550        if (list.size() == 0) {
1551            StringBuilder msg = new StringBuilder();
1552
1553            msg.append("No EmailAddress exists with the key {");
1554
1555            msg.append("companyId=" + companyId);
1556
1557            msg.append(", ");
1558            msg.append("classNameId=" + classNameId);
1559
1560            msg.append(", ");
1561            msg.append("classPK=" + classPK);
1562
1563            msg.append(", ");
1564            msg.append("primary=" + primary);
1565
1566            msg.append(StringPool.CLOSE_CURLY_BRACE);
1567
1568            throw new NoSuchEmailAddressException(msg.toString());
1569        }
1570        else {
1571            return list.get(0);
1572        }
1573    }
1574
1575    public EmailAddress[] findByC_C_C_P_PrevAndNext(long emailAddressId,
1576        long companyId, long classNameId, long classPK, boolean primary,
1577        OrderByComparator obc)
1578        throws NoSuchEmailAddressException, SystemException {
1579        EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
1580
1581        int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1582
1583        Session session = null;
1584
1585        try {
1586            session = openSession();
1587
1588            StringBuilder query = new StringBuilder();
1589
1590            query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
1591
1592            query.append("companyId = ?");
1593
1594            query.append(" AND ");
1595
1596            query.append("classNameId = ?");
1597
1598            query.append(" AND ");
1599
1600            query.append("classPK = ?");
1601
1602            query.append(" AND ");
1603
1604            query.append("primary_ = ?");
1605
1606            query.append(" ");
1607
1608            if (obc != null) {
1609                query.append("ORDER BY ");
1610                query.append(obc.getOrderBy());
1611            }
1612
1613            else {
1614                query.append("ORDER BY ");
1615
1616                query.append("createDate ASC");
1617            }
1618
1619            Query q = session.createQuery(query.toString());
1620
1621            QueryPos qPos = QueryPos.getInstance(q);
1622
1623            qPos.add(companyId);
1624
1625            qPos.add(classNameId);
1626
1627            qPos.add(classPK);
1628
1629            qPos.add(primary);
1630
1631            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1632                    emailAddress);
1633
1634            EmailAddress[] array = new EmailAddressImpl[3];
1635
1636            array[0] = (EmailAddress)objArray[0];
1637            array[1] = (EmailAddress)objArray[1];
1638            array[2] = (EmailAddress)objArray[2];
1639
1640            return array;
1641        }
1642        catch (Exception e) {
1643            throw processException(e);
1644        }
1645        finally {
1646            closeSession(session);
1647        }
1648    }
1649
1650    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1651        throws SystemException {
1652        Session session = null;
1653
1654        try {
1655            session = openSession();
1656
1657            dynamicQuery.compile(session);
1658
1659            return dynamicQuery.list();
1660        }
1661        catch (Exception e) {
1662            throw processException(e);
1663        }
1664        finally {
1665            closeSession(session);
1666        }
1667    }
1668
1669    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1670        int start, int end) throws SystemException {
1671        Session session = null;
1672
1673        try {
1674            session = openSession();
1675
1676            dynamicQuery.setLimit(start, end);
1677
1678            dynamicQuery.compile(session);
1679
1680            return dynamicQuery.list();
1681        }
1682        catch (Exception e) {
1683            throw processException(e);
1684        }
1685        finally {
1686            closeSession(session);
1687        }
1688    }
1689
1690    public List<EmailAddress> findAll() throws SystemException {
1691        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1692    }
1693
1694    public List<EmailAddress> findAll(int start, int end)
1695        throws SystemException {
1696        return findAll(start, end, null);
1697    }
1698
1699    public List<EmailAddress> findAll(int start, int end, OrderByComparator obc)
1700        throws SystemException {
1701        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1702        String finderClassName = EmailAddress.class.getName();
1703        String finderMethodName = "findAll";
1704        String[] finderParams = new String[] {
1705                "java.lang.Integer", "java.lang.Integer",
1706                "com.liferay.portal.kernel.util.OrderByComparator"
1707            };
1708        Object[] finderArgs = new Object[] {
1709                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1710            };
1711
1712        Object result = null;
1713
1714        if (finderClassNameCacheEnabled) {
1715            result = FinderCacheUtil.getResult(finderClassName,
1716                    finderMethodName, finderParams, finderArgs, this);
1717        }
1718
1719        if (result == null) {
1720            Session session = null;
1721
1722            try {
1723                session = openSession();
1724
1725                StringBuilder query = new StringBuilder();
1726
1727                query.append("FROM com.liferay.portal.model.EmailAddress ");
1728
1729                if (obc != null) {
1730                    query.append("ORDER BY ");
1731                    query.append(obc.getOrderBy());
1732                }
1733
1734                else {
1735                    query.append("ORDER BY ");
1736
1737                    query.append("createDate ASC");
1738                }
1739
1740                Query q = session.createQuery(query.toString());
1741
1742                List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
1743                        getDialect(), start, end);
1744
1745                if (obc == null) {
1746                    Collections.sort(list);
1747                }
1748
1749                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1750                    finderClassName, finderMethodName, finderParams,
1751                    finderArgs, list);
1752
1753                return list;
1754            }
1755            catch (Exception e) {
1756                throw processException(e);
1757            }
1758            finally {
1759                closeSession(session);
1760            }
1761        }
1762        else {
1763            return (List<EmailAddress>)result;
1764        }
1765    }
1766
1767    public void removeByCompanyId(long companyId) throws SystemException {
1768        for (EmailAddress emailAddress : findByCompanyId(companyId)) {
1769            remove(emailAddress);
1770        }
1771    }
1772
1773    public void removeByUserId(long userId) throws SystemException {
1774        for (EmailAddress emailAddress : findByUserId(userId)) {
1775            remove(emailAddress);
1776        }
1777    }
1778
1779    public void removeByC_C(long companyId, long classNameId)
1780        throws SystemException {
1781        for (EmailAddress emailAddress : findByC_C(companyId, classNameId)) {
1782            remove(emailAddress);
1783        }
1784    }
1785
1786    public void removeByC_C_C(long companyId, long classNameId, long classPK)
1787        throws SystemException {
1788        for (EmailAddress emailAddress : findByC_C_C(companyId, classNameId,
1789                classPK)) {
1790            remove(emailAddress);
1791        }
1792    }
1793
1794    public void removeByC_C_C_P(long companyId, long classNameId, long classPK,
1795        boolean primary) throws SystemException {
1796        for (EmailAddress emailAddress : findByC_C_C_P(companyId, classNameId,
1797                classPK, primary)) {
1798            remove(emailAddress);
1799        }
1800    }
1801
1802    public void removeAll() throws SystemException {
1803        for (EmailAddress emailAddress : findAll()) {
1804            remove(emailAddress);
1805        }
1806    }
1807
1808    public int countByCompanyId(long companyId) throws SystemException {
1809        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1810        String finderClassName = EmailAddress.class.getName();
1811        String finderMethodName = "countByCompanyId";
1812        String[] finderParams = new String[] { Long.class.getName() };
1813        Object[] finderArgs = new Object[] { new Long(companyId) };
1814
1815        Object result = null;
1816
1817        if (finderClassNameCacheEnabled) {
1818            result = FinderCacheUtil.getResult(finderClassName,
1819                    finderMethodName, finderParams, finderArgs, this);
1820        }
1821
1822        if (result == null) {
1823            Session session = null;
1824
1825            try {
1826                session = openSession();
1827
1828                StringBuilder query = new StringBuilder();
1829
1830                query.append("SELECT COUNT(*) ");
1831                query.append(
1832                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1833
1834                query.append("companyId = ?");
1835
1836                query.append(" ");
1837
1838                Query q = session.createQuery(query.toString());
1839
1840                QueryPos qPos = QueryPos.getInstance(q);
1841
1842                qPos.add(companyId);
1843
1844                Long count = null;
1845
1846                Iterator<Long> itr = q.list().iterator();
1847
1848                if (itr.hasNext()) {
1849                    count = itr.next();
1850                }
1851
1852                if (count == null) {
1853                    count = new Long(0);
1854                }
1855
1856                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1857                    finderClassName, finderMethodName, finderParams,
1858                    finderArgs, count);
1859
1860                return count.intValue();
1861            }
1862            catch (Exception e) {
1863                throw processException(e);
1864            }
1865            finally {
1866                closeSession(session);
1867            }
1868        }
1869        else {
1870            return ((Long)result).intValue();
1871        }
1872    }
1873
1874    public int countByUserId(long userId) throws SystemException {
1875        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1876        String finderClassName = EmailAddress.class.getName();
1877        String finderMethodName = "countByUserId";
1878        String[] finderParams = new String[] { Long.class.getName() };
1879        Object[] finderArgs = new Object[] { new Long(userId) };
1880
1881        Object result = null;
1882
1883        if (finderClassNameCacheEnabled) {
1884            result = FinderCacheUtil.getResult(finderClassName,
1885                    finderMethodName, finderParams, finderArgs, this);
1886        }
1887
1888        if (result == null) {
1889            Session session = null;
1890
1891            try {
1892                session = openSession();
1893
1894                StringBuilder query = new StringBuilder();
1895
1896                query.append("SELECT COUNT(*) ");
1897                query.append(
1898                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1899
1900                query.append("userId = ?");
1901
1902                query.append(" ");
1903
1904                Query q = session.createQuery(query.toString());
1905
1906                QueryPos qPos = QueryPos.getInstance(q);
1907
1908                qPos.add(userId);
1909
1910                Long count = null;
1911
1912                Iterator<Long> itr = q.list().iterator();
1913
1914                if (itr.hasNext()) {
1915                    count = itr.next();
1916                }
1917
1918                if (count == null) {
1919                    count = new Long(0);
1920                }
1921
1922                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1923                    finderClassName, finderMethodName, finderParams,
1924                    finderArgs, count);
1925
1926                return count.intValue();
1927            }
1928            catch (Exception e) {
1929                throw processException(e);
1930            }
1931            finally {
1932                closeSession(session);
1933            }
1934        }
1935        else {
1936            return ((Long)result).intValue();
1937        }
1938    }
1939
1940    public int countByC_C(long companyId, long classNameId)
1941        throws SystemException {
1942        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1943        String finderClassName = EmailAddress.class.getName();
1944        String finderMethodName = "countByC_C";
1945        String[] finderParams = new String[] {
1946                Long.class.getName(), Long.class.getName()
1947            };
1948        Object[] finderArgs = new Object[] {
1949                new Long(companyId), new Long(classNameId)
1950            };
1951
1952        Object result = null;
1953
1954        if (finderClassNameCacheEnabled) {
1955            result = FinderCacheUtil.getResult(finderClassName,
1956                    finderMethodName, finderParams, finderArgs, this);
1957        }
1958
1959        if (result == null) {
1960            Session session = null;
1961
1962            try {
1963                session = openSession();
1964
1965                StringBuilder query = new StringBuilder();
1966
1967                query.append("SELECT COUNT(*) ");
1968                query.append(
1969                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1970
1971                query.append("companyId = ?");
1972
1973                query.append(" AND ");
1974
1975                query.append("classNameId = ?");
1976
1977                query.append(" ");
1978
1979                Query q = session.createQuery(query.toString());
1980
1981                QueryPos qPos = QueryPos.getInstance(q);
1982
1983                qPos.add(companyId);
1984
1985                qPos.add(classNameId);
1986
1987                Long count = null;
1988
1989                Iterator<Long> itr = q.list().iterator();
1990
1991                if (itr.hasNext()) {
1992                    count = itr.next();
1993                }
1994
1995                if (count == null) {
1996                    count = new Long(0);
1997                }
1998
1999                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2000                    finderClassName, finderMethodName, finderParams,
2001                    finderArgs, count);
2002
2003                return count.intValue();
2004            }
2005            catch (Exception e) {
2006                throw processException(e);
2007            }
2008            finally {
2009                closeSession(session);
2010            }
2011        }
2012        else {
2013            return ((Long)result).intValue();
2014        }
2015    }
2016
2017    public int countByC_C_C(long companyId, long classNameId, long classPK)
2018        throws SystemException {
2019        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2020        String finderClassName = EmailAddress.class.getName();
2021        String finderMethodName = "countByC_C_C";
2022        String[] finderParams = new String[] {
2023                Long.class.getName(), Long.class.getName(), Long.class.getName()
2024            };
2025        Object[] finderArgs = new Object[] {
2026                new Long(companyId), new Long(classNameId), new Long(classPK)
2027            };
2028
2029        Object result = null;
2030
2031        if (finderClassNameCacheEnabled) {
2032            result = FinderCacheUtil.getResult(finderClassName,
2033                    finderMethodName, finderParams, finderArgs, this);
2034        }
2035
2036        if (result == null) {
2037            Session session = null;
2038
2039            try {
2040                session = openSession();
2041
2042                StringBuilder query = new StringBuilder();
2043
2044                query.append("SELECT COUNT(*) ");
2045                query.append(
2046                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
2047
2048                query.append("companyId = ?");
2049
2050                query.append(" AND ");
2051
2052                query.append("classNameId = ?");
2053
2054                query.append(" AND ");
2055
2056                query.append("classPK = ?");
2057
2058                query.append(" ");
2059
2060                Query q = session.createQuery(query.toString());
2061
2062                QueryPos qPos = QueryPos.getInstance(q);
2063
2064                qPos.add(companyId);
2065
2066                qPos.add(classNameId);
2067
2068                qPos.add(classPK);
2069
2070                Long count = null;
2071
2072                Iterator<Long> itr = q.list().iterator();
2073
2074                if (itr.hasNext()) {
2075                    count = itr.next();
2076                }
2077
2078                if (count == null) {
2079                    count = new Long(0);
2080                }
2081
2082                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2083                    finderClassName, finderMethodName, finderParams,
2084                    finderArgs, count);
2085
2086                return count.intValue();
2087            }
2088            catch (Exception e) {
2089                throw processException(e);
2090            }
2091            finally {
2092                closeSession(session);
2093            }
2094        }
2095        else {
2096            return ((Long)result).intValue();
2097        }
2098    }
2099
2100    public int countByC_C_C_P(long companyId, long classNameId, long classPK,
2101        boolean primary) throws SystemException {
2102        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2103        String finderClassName = EmailAddress.class.getName();
2104        String finderMethodName = "countByC_C_C_P";
2105        String[] finderParams = new String[] {
2106                Long.class.getName(), Long.class.getName(), Long.class.getName(),
2107                Boolean.class.getName()
2108            };
2109        Object[] finderArgs = new Object[] {
2110                new Long(companyId), new Long(classNameId), new Long(classPK),
2111                Boolean.valueOf(primary)
2112            };
2113
2114        Object result = null;
2115
2116        if (finderClassNameCacheEnabled) {
2117            result = FinderCacheUtil.getResult(finderClassName,
2118                    finderMethodName, finderParams, finderArgs, this);
2119        }
2120
2121        if (result == null) {
2122            Session session = null;
2123
2124            try {
2125                session = openSession();
2126
2127                StringBuilder query = new StringBuilder();
2128
2129                query.append("SELECT COUNT(*) ");
2130                query.append(
2131                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
2132
2133                query.append("companyId = ?");
2134
2135                query.append(" AND ");
2136
2137                query.append("classNameId = ?");
2138
2139                query.append(" AND ");
2140
2141                query.append("classPK = ?");
2142
2143                query.append(" AND ");
2144
2145                query.append("primary_ = ?");
2146
2147                query.append(" ");
2148
2149                Query q = session.createQuery(query.toString());
2150
2151                QueryPos qPos = QueryPos.getInstance(q);
2152
2153                qPos.add(companyId);
2154
2155                qPos.add(classNameId);
2156
2157                qPos.add(classPK);
2158
2159                qPos.add(primary);
2160
2161                Long count = null;
2162
2163                Iterator<Long> itr = q.list().iterator();
2164
2165                if (itr.hasNext()) {
2166                    count = itr.next();
2167                }
2168
2169                if (count == null) {
2170                    count = new Long(0);
2171                }
2172
2173                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2174                    finderClassName, finderMethodName, finderParams,
2175                    finderArgs, count);
2176
2177                return count.intValue();
2178            }
2179            catch (Exception e) {
2180                throw processException(e);
2181            }
2182            finally {
2183                closeSession(session);
2184            }
2185        }
2186        else {
2187            return ((Long)result).intValue();
2188        }
2189    }
2190
2191    public int countAll() throws SystemException {
2192        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2193        String finderClassName = EmailAddress.class.getName();
2194        String finderMethodName = "countAll";
2195        String[] finderParams = new String[] {  };
2196        Object[] finderArgs = new Object[] {  };
2197
2198        Object result = null;
2199
2200        if (finderClassNameCacheEnabled) {
2201            result = FinderCacheUtil.getResult(finderClassName,
2202                    finderMethodName, finderParams, finderArgs, this);
2203        }
2204
2205        if (result == null) {
2206            Session session = null;
2207
2208            try {
2209                session = openSession();
2210
2211                Query q = session.createQuery(
2212                        "SELECT COUNT(*) FROM com.liferay.portal.model.EmailAddress");
2213
2214                Long count = null;
2215
2216                Iterator<Long> itr = q.list().iterator();
2217
2218                if (itr.hasNext()) {
2219                    count = itr.next();
2220                }
2221
2222                if (count == null) {
2223                    count = new Long(0);
2224                }
2225
2226                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2227                    finderClassName, finderMethodName, finderParams,
2228                    finderArgs, count);
2229
2230                return count.intValue();
2231            }
2232            catch (Exception e) {
2233                throw processException(e);
2234            }
2235            finally {
2236                closeSession(session);
2237            }
2238        }
2239        else {
2240            return ((Long)result).intValue();
2241        }
2242    }
2243
2244    public void registerListener(ModelListener listener) {
2245        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2246
2247        listeners.add(listener);
2248
2249        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2250    }
2251
2252    public void unregisterListener(ModelListener listener) {
2253        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2254
2255        listeners.remove(listener);
2256
2257        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2258    }
2259
2260    public void afterPropertiesSet() {
2261        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2262                    com.liferay.portal.util.PropsUtil.get(
2263                        "value.object.listener.com.liferay.portal.model.EmailAddress")));
2264
2265        if (listenerClassNames.length > 0) {
2266            try {
2267                List<ModelListener> listeners = new ArrayList<ModelListener>();
2268
2269                for (String listenerClassName : listenerClassNames) {
2270                    listeners.add((ModelListener)Class.forName(
2271                            listenerClassName).newInstance());
2272                }
2273
2274                _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2275            }
2276            catch (Exception e) {
2277                _log.error(e);
2278            }
2279        }
2280    }
2281
2282    private static Log _log = LogFactory.getLog(EmailAddressPersistenceImpl.class);
2283    private ModelListener[] _listeners = new ModelListener[0];
2284}