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