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             if (BatchSessionUtil.isEnabled()) {
130                 Object staleObject = session.get(EmailAddressImpl.class,
131                         emailAddress.getPrimaryKeyObj());
132 
133                 if (staleObject != null) {
134                     session.evict(staleObject);
135                 }
136             }
137 
138             session.delete(emailAddress);
139 
140             session.flush();
141 
142             return emailAddress;
143         }
144         catch (Exception e) {
145             throw processException(e);
146         }
147         finally {
148             closeSession(session);
149 
150             FinderCacheUtil.clearCache(EmailAddress.class.getName());
151         }
152     }
153 
154     /**
155      * @deprecated Use <code>update(EmailAddress emailAddress, boolean merge)</code>.
156      */
157     public EmailAddress update(EmailAddress emailAddress)
158         throws SystemException {
159         if (_log.isWarnEnabled()) {
160             _log.warn(
161                 "Using the deprecated update(EmailAddress emailAddress) method. Use update(EmailAddress emailAddress, boolean merge) instead.");
162         }
163 
164         return update(emailAddress, false);
165     }
166 
167     /**
168      * Add, update, or merge, the entity. This method also calls the model
169      * listeners to trigger the proper events associated with adding, deleting,
170      * or updating an entity.
171      *
172      * @param        emailAddress the entity to add, update, or merge
173      * @param        merge boolean value for whether to merge the entity. The
174      *                default value is false. Setting merge to true is more
175      *                expensive and should only be true when emailAddress is
176      *                transient. See LEP-5473 for a detailed discussion of this
177      *                method.
178      * @return        true if the portlet can be displayed via Ajax
179      */
180     public EmailAddress update(EmailAddress emailAddress, boolean merge)
181         throws SystemException {
182         boolean isNew = emailAddress.isNew();
183 
184         if (_listeners.length > 0) {
185             for (ModelListener listener : _listeners) {
186                 if (isNew) {
187                     listener.onBeforeCreate(emailAddress);
188                 }
189                 else {
190                     listener.onBeforeUpdate(emailAddress);
191                 }
192             }
193         }
194 
195         emailAddress = updateImpl(emailAddress, merge);
196 
197         if (_listeners.length > 0) {
198             for (ModelListener listener : _listeners) {
199                 if (isNew) {
200                     listener.onAfterCreate(emailAddress);
201                 }
202                 else {
203                     listener.onAfterUpdate(emailAddress);
204                 }
205             }
206         }
207 
208         return emailAddress;
209     }
210 
211     public EmailAddress updateImpl(
212         com.liferay.portal.model.EmailAddress emailAddress, boolean merge)
213         throws SystemException {
214         Session session = null;
215 
216         try {
217             session = openSession();
218 
219             BatchSessionUtil.update(session, emailAddress, merge);
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 = null;
1743
1744                if (obc == null) {
1745                    list = (List<EmailAddress>)QueryUtil.list(q, getDialect(),
1746                            start, end, false);
1747
1748                    Collections.sort(list);
1749                }
1750                else {
1751                    list = (List<EmailAddress>)QueryUtil.list(q, getDialect(),
1752                            start, end);
1753                }
1754
1755                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1756                    finderClassName, finderMethodName, finderParams,
1757                    finderArgs, list);
1758
1759                return list;
1760            }
1761            catch (Exception e) {
1762                throw processException(e);
1763            }
1764            finally {
1765                closeSession(session);
1766            }
1767        }
1768        else {
1769            return (List<EmailAddress>)result;
1770        }
1771    }
1772
1773    public void removeByCompanyId(long companyId) throws SystemException {
1774        for (EmailAddress emailAddress : findByCompanyId(companyId)) {
1775            remove(emailAddress);
1776        }
1777    }
1778
1779    public void removeByUserId(long userId) throws SystemException {
1780        for (EmailAddress emailAddress : findByUserId(userId)) {
1781            remove(emailAddress);
1782        }
1783    }
1784
1785    public void removeByC_C(long companyId, long classNameId)
1786        throws SystemException {
1787        for (EmailAddress emailAddress : findByC_C(companyId, classNameId)) {
1788            remove(emailAddress);
1789        }
1790    }
1791
1792    public void removeByC_C_C(long companyId, long classNameId, long classPK)
1793        throws SystemException {
1794        for (EmailAddress emailAddress : findByC_C_C(companyId, classNameId,
1795                classPK)) {
1796            remove(emailAddress);
1797        }
1798    }
1799
1800    public void removeByC_C_C_P(long companyId, long classNameId, long classPK,
1801        boolean primary) throws SystemException {
1802        for (EmailAddress emailAddress : findByC_C_C_P(companyId, classNameId,
1803                classPK, primary)) {
1804            remove(emailAddress);
1805        }
1806    }
1807
1808    public void removeAll() throws SystemException {
1809        for (EmailAddress emailAddress : findAll()) {
1810            remove(emailAddress);
1811        }
1812    }
1813
1814    public int countByCompanyId(long companyId) throws SystemException {
1815        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1816        String finderClassName = EmailAddress.class.getName();
1817        String finderMethodName = "countByCompanyId";
1818        String[] finderParams = new String[] { Long.class.getName() };
1819        Object[] finderArgs = new Object[] { new Long(companyId) };
1820
1821        Object result = null;
1822
1823        if (finderClassNameCacheEnabled) {
1824            result = FinderCacheUtil.getResult(finderClassName,
1825                    finderMethodName, finderParams, finderArgs, this);
1826        }
1827
1828        if (result == null) {
1829            Session session = null;
1830
1831            try {
1832                session = openSession();
1833
1834                StringBuilder query = new StringBuilder();
1835
1836                query.append("SELECT COUNT(*) ");
1837                query.append(
1838                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1839
1840                query.append("companyId = ?");
1841
1842                query.append(" ");
1843
1844                Query q = session.createQuery(query.toString());
1845
1846                QueryPos qPos = QueryPos.getInstance(q);
1847
1848                qPos.add(companyId);
1849
1850                Long count = null;
1851
1852                Iterator<Long> itr = q.list().iterator();
1853
1854                if (itr.hasNext()) {
1855                    count = itr.next();
1856                }
1857
1858                if (count == null) {
1859                    count = new Long(0);
1860                }
1861
1862                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1863                    finderClassName, finderMethodName, finderParams,
1864                    finderArgs, count);
1865
1866                return count.intValue();
1867            }
1868            catch (Exception e) {
1869                throw processException(e);
1870            }
1871            finally {
1872                closeSession(session);
1873            }
1874        }
1875        else {
1876            return ((Long)result).intValue();
1877        }
1878    }
1879
1880    public int countByUserId(long userId) throws SystemException {
1881        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1882        String finderClassName = EmailAddress.class.getName();
1883        String finderMethodName = "countByUserId";
1884        String[] finderParams = new String[] { Long.class.getName() };
1885        Object[] finderArgs = new Object[] { new Long(userId) };
1886
1887        Object result = null;
1888
1889        if (finderClassNameCacheEnabled) {
1890            result = FinderCacheUtil.getResult(finderClassName,
1891                    finderMethodName, finderParams, finderArgs, this);
1892        }
1893
1894        if (result == null) {
1895            Session session = null;
1896
1897            try {
1898                session = openSession();
1899
1900                StringBuilder query = new StringBuilder();
1901
1902                query.append("SELECT COUNT(*) ");
1903                query.append(
1904                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1905
1906                query.append("userId = ?");
1907
1908                query.append(" ");
1909
1910                Query q = session.createQuery(query.toString());
1911
1912                QueryPos qPos = QueryPos.getInstance(q);
1913
1914                qPos.add(userId);
1915
1916                Long count = null;
1917
1918                Iterator<Long> itr = q.list().iterator();
1919
1920                if (itr.hasNext()) {
1921                    count = itr.next();
1922                }
1923
1924                if (count == null) {
1925                    count = new Long(0);
1926                }
1927
1928                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1929                    finderClassName, finderMethodName, finderParams,
1930                    finderArgs, count);
1931
1932                return count.intValue();
1933            }
1934            catch (Exception e) {
1935                throw processException(e);
1936            }
1937            finally {
1938                closeSession(session);
1939            }
1940        }
1941        else {
1942            return ((Long)result).intValue();
1943        }
1944    }
1945
1946    public int countByC_C(long companyId, long classNameId)
1947        throws SystemException {
1948        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1949        String finderClassName = EmailAddress.class.getName();
1950        String finderMethodName = "countByC_C";
1951        String[] finderParams = new String[] {
1952                Long.class.getName(), Long.class.getName()
1953            };
1954        Object[] finderArgs = new Object[] {
1955                new Long(companyId), new Long(classNameId)
1956            };
1957
1958        Object result = null;
1959
1960        if (finderClassNameCacheEnabled) {
1961            result = FinderCacheUtil.getResult(finderClassName,
1962                    finderMethodName, finderParams, finderArgs, this);
1963        }
1964
1965        if (result == null) {
1966            Session session = null;
1967
1968            try {
1969                session = openSession();
1970
1971                StringBuilder query = new StringBuilder();
1972
1973                query.append("SELECT COUNT(*) ");
1974                query.append(
1975                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1976
1977                query.append("companyId = ?");
1978
1979                query.append(" AND ");
1980
1981                query.append("classNameId = ?");
1982
1983                query.append(" ");
1984
1985                Query q = session.createQuery(query.toString());
1986
1987                QueryPos qPos = QueryPos.getInstance(q);
1988
1989                qPos.add(companyId);
1990
1991                qPos.add(classNameId);
1992
1993                Long count = null;
1994
1995                Iterator<Long> itr = q.list().iterator();
1996
1997                if (itr.hasNext()) {
1998                    count = itr.next();
1999                }
2000
2001                if (count == null) {
2002                    count = new Long(0);
2003                }
2004
2005                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2006                    finderClassName, finderMethodName, finderParams,
2007                    finderArgs, count);
2008
2009                return count.intValue();
2010            }
2011            catch (Exception e) {
2012                throw processException(e);
2013            }
2014            finally {
2015                closeSession(session);
2016            }
2017        }
2018        else {
2019            return ((Long)result).intValue();
2020        }
2021    }
2022
2023    public int countByC_C_C(long companyId, long classNameId, long classPK)
2024        throws SystemException {
2025        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2026        String finderClassName = EmailAddress.class.getName();
2027        String finderMethodName = "countByC_C_C";
2028        String[] finderParams = new String[] {
2029                Long.class.getName(), Long.class.getName(), Long.class.getName()
2030            };
2031        Object[] finderArgs = new Object[] {
2032                new Long(companyId), new Long(classNameId), new Long(classPK)
2033            };
2034
2035        Object result = null;
2036
2037        if (finderClassNameCacheEnabled) {
2038            result = FinderCacheUtil.getResult(finderClassName,
2039                    finderMethodName, finderParams, finderArgs, this);
2040        }
2041
2042        if (result == null) {
2043            Session session = null;
2044
2045            try {
2046                session = openSession();
2047
2048                StringBuilder query = new StringBuilder();
2049
2050                query.append("SELECT COUNT(*) ");
2051                query.append(
2052                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
2053
2054                query.append("companyId = ?");
2055
2056                query.append(" AND ");
2057
2058                query.append("classNameId = ?");
2059
2060                query.append(" AND ");
2061
2062                query.append("classPK = ?");
2063
2064                query.append(" ");
2065
2066                Query q = session.createQuery(query.toString());
2067
2068                QueryPos qPos = QueryPos.getInstance(q);
2069
2070                qPos.add(companyId);
2071
2072                qPos.add(classNameId);
2073
2074                qPos.add(classPK);
2075
2076                Long count = null;
2077
2078                Iterator<Long> itr = q.list().iterator();
2079
2080                if (itr.hasNext()) {
2081                    count = itr.next();
2082                }
2083
2084                if (count == null) {
2085                    count = new Long(0);
2086                }
2087
2088                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2089                    finderClassName, finderMethodName, finderParams,
2090                    finderArgs, count);
2091
2092                return count.intValue();
2093            }
2094            catch (Exception e) {
2095                throw processException(e);
2096            }
2097            finally {
2098                closeSession(session);
2099            }
2100        }
2101        else {
2102            return ((Long)result).intValue();
2103        }
2104    }
2105
2106    public int countByC_C_C_P(long companyId, long classNameId, long classPK,
2107        boolean primary) throws SystemException {
2108        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2109        String finderClassName = EmailAddress.class.getName();
2110        String finderMethodName = "countByC_C_C_P";
2111        String[] finderParams = new String[] {
2112                Long.class.getName(), Long.class.getName(), Long.class.getName(),
2113                Boolean.class.getName()
2114            };
2115        Object[] finderArgs = new Object[] {
2116                new Long(companyId), new Long(classNameId), new Long(classPK),
2117                Boolean.valueOf(primary)
2118            };
2119
2120        Object result = null;
2121
2122        if (finderClassNameCacheEnabled) {
2123            result = FinderCacheUtil.getResult(finderClassName,
2124                    finderMethodName, finderParams, finderArgs, this);
2125        }
2126
2127        if (result == null) {
2128            Session session = null;
2129
2130            try {
2131                session = openSession();
2132
2133                StringBuilder query = new StringBuilder();
2134
2135                query.append("SELECT COUNT(*) ");
2136                query.append(
2137                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
2138
2139                query.append("companyId = ?");
2140
2141                query.append(" AND ");
2142
2143                query.append("classNameId = ?");
2144
2145                query.append(" AND ");
2146
2147                query.append("classPK = ?");
2148
2149                query.append(" AND ");
2150
2151                query.append("primary_ = ?");
2152
2153                query.append(" ");
2154
2155                Query q = session.createQuery(query.toString());
2156
2157                QueryPos qPos = QueryPos.getInstance(q);
2158
2159                qPos.add(companyId);
2160
2161                qPos.add(classNameId);
2162
2163                qPos.add(classPK);
2164
2165                qPos.add(primary);
2166
2167                Long count = null;
2168
2169                Iterator<Long> itr = q.list().iterator();
2170
2171                if (itr.hasNext()) {
2172                    count = itr.next();
2173                }
2174
2175                if (count == null) {
2176                    count = new Long(0);
2177                }
2178
2179                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2180                    finderClassName, finderMethodName, finderParams,
2181                    finderArgs, count);
2182
2183                return count.intValue();
2184            }
2185            catch (Exception e) {
2186                throw processException(e);
2187            }
2188            finally {
2189                closeSession(session);
2190            }
2191        }
2192        else {
2193            return ((Long)result).intValue();
2194        }
2195    }
2196
2197    public int countAll() throws SystemException {
2198        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2199        String finderClassName = EmailAddress.class.getName();
2200        String finderMethodName = "countAll";
2201        String[] finderParams = new String[] {  };
2202        Object[] finderArgs = new Object[] {  };
2203
2204        Object result = null;
2205
2206        if (finderClassNameCacheEnabled) {
2207            result = FinderCacheUtil.getResult(finderClassName,
2208                    finderMethodName, finderParams, finderArgs, this);
2209        }
2210
2211        if (result == null) {
2212            Session session = null;
2213
2214            try {
2215                session = openSession();
2216
2217                Query q = session.createQuery(
2218                        "SELECT COUNT(*) FROM com.liferay.portal.model.EmailAddress");
2219
2220                Long count = null;
2221
2222                Iterator<Long> itr = q.list().iterator();
2223
2224                if (itr.hasNext()) {
2225                    count = itr.next();
2226                }
2227
2228                if (count == null) {
2229                    count = new Long(0);
2230                }
2231
2232                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2233                    finderClassName, finderMethodName, finderParams,
2234                    finderArgs, count);
2235
2236                return count.intValue();
2237            }
2238            catch (Exception e) {
2239                throw processException(e);
2240            }
2241            finally {
2242                closeSession(session);
2243            }
2244        }
2245        else {
2246            return ((Long)result).intValue();
2247        }
2248    }
2249
2250    public void registerListener(ModelListener listener) {
2251        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2252
2253        listeners.add(listener);
2254
2255        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2256    }
2257
2258    public void unregisterListener(ModelListener listener) {
2259        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2260
2261        listeners.remove(listener);
2262
2263        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2264    }
2265
2266    public void afterPropertiesSet() {
2267        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2268                    com.liferay.portal.util.PropsUtil.get(
2269                        "value.object.listener.com.liferay.portal.model.EmailAddress")));
2270
2271        if (listenerClassNames.length > 0) {
2272            try {
2273                List<ModelListener> listeners = new ArrayList<ModelListener>();
2274
2275                for (String listenerClassName : listenerClassNames) {
2276                    listeners.add((ModelListener)Class.forName(
2277                            listenerClassName).newInstance());
2278                }
2279
2280                _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2281            }
2282            catch (Exception e) {
2283                _log.error(e);
2284            }
2285        }
2286    }
2287
2288    private static Log _log = LogFactory.getLog(EmailAddressPersistenceImpl.class);
2289    private ModelListener[] _listeners = new ModelListener[0];
2290}