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