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