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             if (BatchSessionUtil.isEnabled()) {
127                 Object staleObject = session.get(AddressImpl.class,
128                         address.getPrimaryKeyObj());
129 
130                 if (staleObject != null) {
131                     session.evict(staleObject);
132                 }
133             }
134 
135             session.delete(address);
136 
137             session.flush();
138 
139             return address;
140         }
141         catch (Exception e) {
142             throw processException(e);
143         }
144         finally {
145             closeSession(session);
146 
147             FinderCacheUtil.clearCache(Address.class.getName());
148         }
149     }
150 
151     /**
152      * @deprecated Use <code>update(Address address, boolean merge)</code>.
153      */
154     public Address update(Address address) throws SystemException {
155         if (_log.isWarnEnabled()) {
156             _log.warn(
157                 "Using the deprecated update(Address address) method. Use update(Address address, boolean merge) instead.");
158         }
159 
160         return update(address, false);
161     }
162 
163     /**
164      * Add, update, or merge, the entity. This method also calls the model
165      * listeners to trigger the proper events associated with adding, deleting,
166      * or updating an entity.
167      *
168      * @param        address the entity to add, update, or merge
169      * @param        merge boolean value for whether to merge the entity. The
170      *                default value is false. Setting merge to true is more
171      *                expensive and should only be true when address is
172      *                transient. See LEP-5473 for a detailed discussion of this
173      *                method.
174      * @return        true if the portlet can be displayed via Ajax
175      */
176     public Address update(Address address, boolean merge)
177         throws SystemException {
178         boolean isNew = address.isNew();
179 
180         if (_listeners.length > 0) {
181             for (ModelListener listener : _listeners) {
182                 if (isNew) {
183                     listener.onBeforeCreate(address);
184                 }
185                 else {
186                     listener.onBeforeUpdate(address);
187                 }
188             }
189         }
190 
191         address = updateImpl(address, merge);
192 
193         if (_listeners.length > 0) {
194             for (ModelListener listener : _listeners) {
195                 if (isNew) {
196                     listener.onAfterCreate(address);
197                 }
198                 else {
199                     listener.onAfterUpdate(address);
200                 }
201             }
202         }
203 
204         return address;
205     }
206 
207     public Address updateImpl(com.liferay.portal.model.Address address,
208         boolean merge) throws SystemException {
209         Session session = null;
210 
211         try {
212             session = openSession();
213 
214             BatchSessionUtil.update(session, address, merge);
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 = null;
2035
2036                if (obc == null) {
2037                    list = (List<Address>)QueryUtil.list(q, getDialect(),
2038                            start, end, false);
2039
2040                    Collections.sort(list);
2041                }
2042                else {
2043                    list = (List<Address>)QueryUtil.list(q, getDialect(),
2044                            start, end);
2045                }
2046
2047                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2048                    finderClassName, finderMethodName, finderParams,
2049                    finderArgs, list);
2050
2051                return list;
2052            }
2053            catch (Exception e) {
2054                throw processException(e);
2055            }
2056            finally {
2057                closeSession(session);
2058            }
2059        }
2060        else {
2061            return (List<Address>)result;
2062        }
2063    }
2064
2065    public void removeByCompanyId(long companyId) throws SystemException {
2066        for (Address address : findByCompanyId(companyId)) {
2067            remove(address);
2068        }
2069    }
2070
2071    public void removeByUserId(long userId) throws SystemException {
2072        for (Address address : findByUserId(userId)) {
2073            remove(address);
2074        }
2075    }
2076
2077    public void removeByC_C(long companyId, long classNameId)
2078        throws SystemException {
2079        for (Address address : findByC_C(companyId, classNameId)) {
2080            remove(address);
2081        }
2082    }
2083
2084    public void removeByC_C_C(long companyId, long classNameId, long classPK)
2085        throws SystemException {
2086        for (Address address : findByC_C_C(companyId, classNameId, classPK)) {
2087            remove(address);
2088        }
2089    }
2090
2091    public void removeByC_C_C_M(long companyId, long classNameId, long classPK,
2092        boolean mailing) throws SystemException {
2093        for (Address address : findByC_C_C_M(companyId, classNameId, classPK,
2094                mailing)) {
2095            remove(address);
2096        }
2097    }
2098
2099    public void removeByC_C_C_P(long companyId, long classNameId, long classPK,
2100        boolean primary) throws SystemException {
2101        for (Address address : findByC_C_C_P(companyId, classNameId, classPK,
2102                primary)) {
2103            remove(address);
2104        }
2105    }
2106
2107    public void removeAll() throws SystemException {
2108        for (Address address : findAll()) {
2109            remove(address);
2110        }
2111    }
2112
2113    public int countByCompanyId(long companyId) throws SystemException {
2114        boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2115        String finderClassName = Address.class.getName();
2116        String finderMethodName = "countByCompanyId";
2117        String[] finderParams = new String[] { Long.class.getName() };
2118        Object[] finderArgs = new Object[] { new Long(companyId) };
2119
2120        Object result = null;
2121
2122        if (finderClassNameCacheEnabled) {
2123            result = FinderCacheUtil.getResult(finderClassName,
2124                    finderMethodName, finderParams, finderArgs, this);
2125        }
2126
2127        if (result == null) {
2128            Session session = null;
2129
2130            try {
2131                session = openSession();
2132
2133                StringBuilder query = new StringBuilder();
2134
2135                query.append("SELECT COUNT(*) ");
2136                query.append("FROM com.liferay.portal.model.Address WHERE ");
2137
2138                query.append("companyId = ?");
2139
2140                query.append(" ");
2141
2142                Query q = session.createQuery(query.toString());
2143
2144                QueryPos qPos = QueryPos.getInstance(q);
2145
2146                qPos.add(companyId);
2147
2148                Long count = null;
2149
2150                Iterator<Long> itr = q.list().iterator();
2151
2152                if (itr.hasNext()) {
2153                    count = itr.next();
2154                }
2155
2156                if (count == null) {
2157                    count = new Long(0);
2158                }
2159
2160                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2161                    finderClassName, finderMethodName, finderParams,
2162                    finderArgs, count);
2163
2164                return count.intValue();
2165            }
2166            catch (Exception e) {
2167                throw processException(e);
2168            }
2169            finally {
2170                closeSession(session);
2171            }
2172        }
2173        else {
2174            return ((Long)result).intValue();
2175        }
2176    }
2177
2178    public int countByUserId(long userId) throws SystemException {
2179        boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2180        String finderClassName = Address.class.getName();
2181        String finderMethodName = "countByUserId";
2182        String[] finderParams = new String[] { Long.class.getName() };
2183        Object[] finderArgs = new Object[] { new Long(userId) };
2184
2185        Object result = null;
2186
2187        if (finderClassNameCacheEnabled) {
2188            result = FinderCacheUtil.getResult(finderClassName,
2189                    finderMethodName, finderParams, finderArgs, this);
2190        }
2191
2192        if (result == null) {
2193            Session session = null;
2194
2195            try {
2196                session = openSession();
2197
2198                StringBuilder query = new StringBuilder();
2199
2200                query.append("SELECT COUNT(*) ");
2201                query.append("FROM com.liferay.portal.model.Address WHERE ");
2202
2203                query.append("userId = ?");
2204
2205                query.append(" ");
2206
2207                Query q = session.createQuery(query.toString());
2208
2209                QueryPos qPos = QueryPos.getInstance(q);
2210
2211                qPos.add(userId);
2212
2213                Long count = null;
2214
2215                Iterator<Long> itr = q.list().iterator();
2216
2217                if (itr.hasNext()) {
2218                    count = itr.next();
2219                }
2220
2221                if (count == null) {
2222                    count = new Long(0);
2223                }
2224
2225                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2226                    finderClassName, finderMethodName, finderParams,
2227                    finderArgs, count);
2228
2229                return count.intValue();
2230            }
2231            catch (Exception e) {
2232                throw processException(e);
2233            }
2234            finally {
2235                closeSession(session);
2236            }
2237        }
2238        else {
2239            return ((Long)result).intValue();
2240        }
2241    }
2242
2243    public int countByC_C(long companyId, long classNameId)
2244        throws SystemException {
2245        boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2246        String finderClassName = Address.class.getName();
2247        String finderMethodName = "countByC_C";
2248        String[] finderParams = new String[] {
2249                Long.class.getName(), Long.class.getName()
2250            };
2251        Object[] finderArgs = new Object[] {
2252                new Long(companyId), new Long(classNameId)
2253            };
2254
2255        Object result = null;
2256
2257        if (finderClassNameCacheEnabled) {
2258            result = FinderCacheUtil.getResult(finderClassName,
2259                    finderMethodName, finderParams, finderArgs, this);
2260        }
2261
2262        if (result == null) {
2263            Session session = null;
2264
2265            try {
2266                session = openSession();
2267
2268                StringBuilder query = new StringBuilder();
2269
2270                query.append("SELECT COUNT(*) ");
2271                query.append("FROM com.liferay.portal.model.Address WHERE ");
2272
2273                query.append("companyId = ?");
2274
2275                query.append(" AND ");
2276
2277                query.append("classNameId = ?");
2278
2279                query.append(" ");
2280
2281                Query q = session.createQuery(query.toString());
2282
2283                QueryPos qPos = QueryPos.getInstance(q);
2284
2285                qPos.add(companyId);
2286
2287                qPos.add(classNameId);
2288
2289                Long count = null;
2290
2291                Iterator<Long> itr = q.list().iterator();
2292
2293                if (itr.hasNext()) {
2294                    count = itr.next();
2295                }
2296
2297                if (count == null) {
2298                    count = new Long(0);
2299                }
2300
2301                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2302                    finderClassName, finderMethodName, finderParams,
2303                    finderArgs, count);
2304
2305                return count.intValue();
2306            }
2307            catch (Exception e) {
2308                throw processException(e);
2309            }
2310            finally {
2311                closeSession(session);
2312            }
2313        }
2314        else {
2315            return ((Long)result).intValue();
2316        }
2317    }
2318
2319    public int countByC_C_C(long companyId, long classNameId, long classPK)
2320        throws SystemException {
2321        boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2322        String finderClassName = Address.class.getName();
2323        String finderMethodName = "countByC_C_C";
2324        String[] finderParams = new String[] {
2325                Long.class.getName(), Long.class.getName(), Long.class.getName()
2326            };
2327        Object[] finderArgs = new Object[] {
2328                new Long(companyId), new Long(classNameId), new Long(classPK)
2329            };
2330
2331        Object result = null;
2332
2333        if (finderClassNameCacheEnabled) {
2334            result = FinderCacheUtil.getResult(finderClassName,
2335                    finderMethodName, finderParams, finderArgs, this);
2336        }
2337
2338        if (result == null) {
2339            Session session = null;
2340
2341            try {
2342                session = openSession();
2343
2344                StringBuilder query = new StringBuilder();
2345
2346                query.append("SELECT COUNT(*) ");
2347                query.append("FROM com.liferay.portal.model.Address WHERE ");
2348
2349                query.append("companyId = ?");
2350
2351                query.append(" AND ");
2352
2353                query.append("classNameId = ?");
2354
2355                query.append(" AND ");
2356
2357                query.append("classPK = ?");
2358
2359                query.append(" ");
2360
2361                Query q = session.createQuery(query.toString());
2362
2363                QueryPos qPos = QueryPos.getInstance(q);
2364
2365                qPos.add(companyId);
2366
2367                qPos.add(classNameId);
2368
2369                qPos.add(classPK);
2370
2371                Long count = null;
2372
2373                Iterator<Long> itr = q.list().iterator();
2374
2375                if (itr.hasNext()) {
2376                    count = itr.next();
2377                }
2378
2379                if (count == null) {
2380                    count = new Long(0);
2381                }
2382
2383                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2384                    finderClassName, finderMethodName, finderParams,
2385                    finderArgs, count);
2386
2387                return count.intValue();
2388            }
2389            catch (Exception e) {
2390                throw processException(e);
2391            }
2392            finally {
2393                closeSession(session);
2394            }
2395        }
2396        else {
2397            return ((Long)result).intValue();
2398        }
2399    }
2400
2401    public int countByC_C_C_M(long companyId, long classNameId, long classPK,
2402        boolean mailing) throws SystemException {
2403        boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2404        String finderClassName = Address.class.getName();
2405        String finderMethodName = "countByC_C_C_M";
2406        String[] finderParams = new String[] {
2407                Long.class.getName(), Long.class.getName(), Long.class.getName(),
2408                Boolean.class.getName()
2409            };
2410        Object[] finderArgs = new Object[] {
2411                new Long(companyId), new Long(classNameId), new Long(classPK),
2412                Boolean.valueOf(mailing)
2413            };
2414
2415        Object result = null;
2416
2417        if (finderClassNameCacheEnabled) {
2418            result = FinderCacheUtil.getResult(finderClassName,
2419                    finderMethodName, finderParams, finderArgs, this);
2420        }
2421
2422        if (result == null) {
2423            Session session = null;
2424
2425            try {
2426                session = openSession();
2427
2428                StringBuilder query = new StringBuilder();
2429
2430                query.append("SELECT COUNT(*) ");
2431                query.append("FROM com.liferay.portal.model.Address WHERE ");
2432
2433                query.append("companyId = ?");
2434
2435                query.append(" AND ");
2436
2437                query.append("classNameId = ?");
2438
2439                query.append(" AND ");
2440
2441                query.append("classPK = ?");
2442
2443                query.append(" AND ");
2444
2445                query.append("mailing = ?");
2446
2447                query.append(" ");
2448
2449                Query q = session.createQuery(query.toString());
2450
2451                QueryPos qPos = QueryPos.getInstance(q);
2452
2453                qPos.add(companyId);
2454
2455                qPos.add(classNameId);
2456
2457                qPos.add(classPK);
2458
2459                qPos.add(mailing);
2460
2461                Long count = null;
2462
2463                Iterator<Long> itr = q.list().iterator();
2464
2465                if (itr.hasNext()) {
2466                    count = itr.next();
2467                }
2468
2469                if (count == null) {
2470                    count = new Long(0);
2471                }
2472
2473                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2474                    finderClassName, finderMethodName, finderParams,
2475                    finderArgs, count);
2476
2477                return count.intValue();
2478            }
2479            catch (Exception e) {
2480                throw processException(e);
2481            }
2482            finally {
2483                closeSession(session);
2484            }
2485        }
2486        else {
2487            return ((Long)result).intValue();
2488        }
2489    }
2490
2491    public int countByC_C_C_P(long companyId, long classNameId, long classPK,
2492        boolean primary) throws SystemException {
2493        boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2494        String finderClassName = Address.class.getName();
2495        String finderMethodName = "countByC_C_C_P";
2496        String[] finderParams = new String[] {
2497                Long.class.getName(), Long.class.getName(), Long.class.getName(),
2498                Boolean.class.getName()
2499            };
2500        Object[] finderArgs = new Object[] {
2501                new Long(companyId), new Long(classNameId), new Long(classPK),
2502                Boolean.valueOf(primary)
2503            };
2504
2505        Object result = null;
2506
2507        if (finderClassNameCacheEnabled) {
2508            result = FinderCacheUtil.getResult(finderClassName,
2509                    finderMethodName, finderParams, finderArgs, this);
2510        }
2511
2512        if (result == null) {
2513            Session session = null;
2514
2515            try {
2516                session = openSession();
2517
2518                StringBuilder query = new StringBuilder();
2519
2520                query.append("SELECT COUNT(*) ");
2521                query.append("FROM com.liferay.portal.model.Address WHERE ");
2522
2523                query.append("companyId = ?");
2524
2525                query.append(" AND ");
2526
2527                query.append("classNameId = ?");
2528
2529                query.append(" AND ");
2530
2531                query.append("classPK = ?");
2532
2533                query.append(" AND ");
2534
2535                query.append("primary_ = ?");
2536
2537                query.append(" ");
2538
2539                Query q = session.createQuery(query.toString());
2540
2541                QueryPos qPos = QueryPos.getInstance(q);
2542
2543                qPos.add(companyId);
2544
2545                qPos.add(classNameId);
2546
2547                qPos.add(classPK);
2548
2549                qPos.add(primary);
2550
2551                Long count = null;
2552
2553                Iterator<Long> itr = q.list().iterator();
2554
2555                if (itr.hasNext()) {
2556                    count = itr.next();
2557                }
2558
2559                if (count == null) {
2560                    count = new Long(0);
2561                }
2562
2563                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2564                    finderClassName, finderMethodName, finderParams,
2565                    finderArgs, count);
2566
2567                return count.intValue();
2568            }
2569            catch (Exception e) {
2570                throw processException(e);
2571            }
2572            finally {
2573                closeSession(session);
2574            }
2575        }
2576        else {
2577            return ((Long)result).intValue();
2578        }
2579    }
2580
2581    public int countAll() throws SystemException {
2582        boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2583        String finderClassName = Address.class.getName();
2584        String finderMethodName = "countAll";
2585        String[] finderParams = new String[] {  };
2586        Object[] finderArgs = new Object[] {  };
2587
2588        Object result = null;
2589
2590        if (finderClassNameCacheEnabled) {
2591            result = FinderCacheUtil.getResult(finderClassName,
2592                    finderMethodName, finderParams, finderArgs, this);
2593        }
2594
2595        if (result == null) {
2596            Session session = null;
2597
2598            try {
2599                session = openSession();
2600
2601                Query q = session.createQuery(
2602                        "SELECT COUNT(*) FROM com.liferay.portal.model.Address");
2603
2604                Long count = null;
2605
2606                Iterator<Long> itr = q.list().iterator();
2607
2608                if (itr.hasNext()) {
2609                    count = itr.next();
2610                }
2611
2612                if (count == null) {
2613                    count = new Long(0);
2614                }
2615
2616                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2617                    finderClassName, finderMethodName, finderParams,
2618                    finderArgs, count);
2619
2620                return count.intValue();
2621            }
2622            catch (Exception e) {
2623                throw processException(e);
2624            }
2625            finally {
2626                closeSession(session);
2627            }
2628        }
2629        else {
2630            return ((Long)result).intValue();
2631        }
2632    }
2633
2634    public void registerListener(ModelListener listener) {
2635        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2636
2637        listeners.add(listener);
2638
2639        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2640    }
2641
2642    public void unregisterListener(ModelListener listener) {
2643        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2644
2645        listeners.remove(listener);
2646
2647        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2648    }
2649
2650    public void afterPropertiesSet() {
2651        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2652                    com.liferay.portal.util.PropsUtil.get(
2653                        "value.object.listener.com.liferay.portal.model.Address")));
2654
2655        if (listenerClassNames.length > 0) {
2656            try {
2657                List<ModelListener> listeners = new ArrayList<ModelListener>();
2658
2659                for (String listenerClassName : listenerClassNames) {
2660                    listeners.add((ModelListener)Class.forName(
2661                            listenerClassName).newInstance());
2662                }
2663
2664                _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2665            }
2666            catch (Exception e) {
2667                _log.error(e);
2668            }
2669        }
2670    }
2671
2672    private static Log _log = LogFactory.getLog(AddressPersistenceImpl.class);
2673    private ModelListener[] _listeners = new ModelListener[0];
2674}