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