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