1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portlet.shopping.service.persistence;
24  
25  import com.liferay.portal.SystemException;
26  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
27  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
28  import com.liferay.portal.kernel.dao.orm.Query;
29  import com.liferay.portal.kernel.dao.orm.QueryPos;
30  import com.liferay.portal.kernel.dao.orm.QueryUtil;
31  import com.liferay.portal.kernel.dao.orm.Session;
32  import com.liferay.portal.kernel.util.GetterUtil;
33  import com.liferay.portal.kernel.util.ListUtil;
34  import com.liferay.portal.kernel.util.OrderByComparator;
35  import com.liferay.portal.kernel.util.StringPool;
36  import com.liferay.portal.kernel.util.StringUtil;
37  import com.liferay.portal.model.ModelListener;
38  import com.liferay.portal.service.persistence.BatchSessionUtil;
39  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
40  
41  import com.liferay.portlet.shopping.NoSuchOrderItemException;
42  import com.liferay.portlet.shopping.model.ShoppingOrderItem;
43  import com.liferay.portlet.shopping.model.impl.ShoppingOrderItemImpl;
44  import com.liferay.portlet.shopping.model.impl.ShoppingOrderItemModelImpl;
45  
46  import org.apache.commons.logging.Log;
47  import org.apache.commons.logging.LogFactory;
48  
49  import java.util.ArrayList;
50  import java.util.Collections;
51  import java.util.Iterator;
52  import java.util.List;
53  
54  /**
55   * <a href="ShoppingOrderItemPersistenceImpl.java.html"><b><i>View Source</i></b></a>
56   *
57   * @author Brian Wing Shun Chan
58   *
59   */
60  public class ShoppingOrderItemPersistenceImpl extends BasePersistenceImpl
61      implements ShoppingOrderItemPersistence {
62      public ShoppingOrderItem create(long orderItemId) {
63          ShoppingOrderItem shoppingOrderItem = new ShoppingOrderItemImpl();
64  
65          shoppingOrderItem.setNew(true);
66          shoppingOrderItem.setPrimaryKey(orderItemId);
67  
68          return shoppingOrderItem;
69      }
70  
71      public ShoppingOrderItem remove(long orderItemId)
72          throws NoSuchOrderItemException, SystemException {
73          Session session = null;
74  
75          try {
76              session = openSession();
77  
78              ShoppingOrderItem shoppingOrderItem = (ShoppingOrderItem)session.get(ShoppingOrderItemImpl.class,
79                      new Long(orderItemId));
80  
81              if (shoppingOrderItem == null) {
82                  if (_log.isWarnEnabled()) {
83                      _log.warn(
84                          "No ShoppingOrderItem exists with the primary key " +
85                          orderItemId);
86                  }
87  
88                  throw new NoSuchOrderItemException(
89                      "No ShoppingOrderItem exists with the primary key " +
90                      orderItemId);
91              }
92  
93              return remove(shoppingOrderItem);
94          }
95          catch (NoSuchOrderItemException nsee) {
96              throw nsee;
97          }
98          catch (Exception e) {
99              throw processException(e);
100         }
101         finally {
102             closeSession(session);
103         }
104     }
105 
106     public ShoppingOrderItem remove(ShoppingOrderItem shoppingOrderItem)
107         throws SystemException {
108         if (_listeners.length > 0) {
109             for (ModelListener listener : _listeners) {
110                 listener.onBeforeRemove(shoppingOrderItem);
111             }
112         }
113 
114         shoppingOrderItem = removeImpl(shoppingOrderItem);
115 
116         if (_listeners.length > 0) {
117             for (ModelListener listener : _listeners) {
118                 listener.onAfterRemove(shoppingOrderItem);
119             }
120         }
121 
122         return shoppingOrderItem;
123     }
124 
125     protected ShoppingOrderItem removeImpl(ShoppingOrderItem shoppingOrderItem)
126         throws SystemException {
127         Session session = null;
128 
129         try {
130             session = openSession();
131 
132             if (BatchSessionUtil.isEnabled()) {
133                 Object staleObject = session.get(ShoppingOrderItemImpl.class,
134                         shoppingOrderItem.getPrimaryKeyObj());
135 
136                 if (staleObject != null) {
137                     session.evict(staleObject);
138                 }
139             }
140 
141             session.delete(shoppingOrderItem);
142 
143             session.flush();
144 
145             return shoppingOrderItem;
146         }
147         catch (Exception e) {
148             throw processException(e);
149         }
150         finally {
151             closeSession(session);
152 
153             FinderCacheUtil.clearCache(ShoppingOrderItem.class.getName());
154         }
155     }
156 
157     /**
158      * @deprecated Use <code>update(ShoppingOrderItem shoppingOrderItem, boolean merge)</code>.
159      */
160     public ShoppingOrderItem update(ShoppingOrderItem shoppingOrderItem)
161         throws SystemException {
162         if (_log.isWarnEnabled()) {
163             _log.warn(
164                 "Using the deprecated update(ShoppingOrderItem shoppingOrderItem) method. Use update(ShoppingOrderItem shoppingOrderItem, boolean merge) instead.");
165         }
166 
167         return update(shoppingOrderItem, false);
168     }
169 
170     /**
171      * Add, update, or merge, the entity. This method also calls the model
172      * listeners to trigger the proper events associated with adding, deleting,
173      * or updating an entity.
174      *
175      * @param        shoppingOrderItem the entity to add, update, or merge
176      * @param        merge boolean value for whether to merge the entity. The
177      *                default value is false. Setting merge to true is more
178      *                expensive and should only be true when shoppingOrderItem is
179      *                transient. See LEP-5473 for a detailed discussion of this
180      *                method.
181      * @return        true if the portlet can be displayed via Ajax
182      */
183     public ShoppingOrderItem update(ShoppingOrderItem shoppingOrderItem,
184         boolean merge) throws SystemException {
185         boolean isNew = shoppingOrderItem.isNew();
186 
187         if (_listeners.length > 0) {
188             for (ModelListener listener : _listeners) {
189                 if (isNew) {
190                     listener.onBeforeCreate(shoppingOrderItem);
191                 }
192                 else {
193                     listener.onBeforeUpdate(shoppingOrderItem);
194                 }
195             }
196         }
197 
198         shoppingOrderItem = updateImpl(shoppingOrderItem, merge);
199 
200         if (_listeners.length > 0) {
201             for (ModelListener listener : _listeners) {
202                 if (isNew) {
203                     listener.onAfterCreate(shoppingOrderItem);
204                 }
205                 else {
206                     listener.onAfterUpdate(shoppingOrderItem);
207                 }
208             }
209         }
210 
211         return shoppingOrderItem;
212     }
213 
214     public ShoppingOrderItem updateImpl(
215         com.liferay.portlet.shopping.model.ShoppingOrderItem shoppingOrderItem,
216         boolean merge) throws SystemException {
217         Session session = null;
218 
219         try {
220             session = openSession();
221 
222             BatchSessionUtil.update(session, shoppingOrderItem, merge);
223 
224             shoppingOrderItem.setNew(false);
225 
226             return shoppingOrderItem;
227         }
228         catch (Exception e) {
229             throw processException(e);
230         }
231         finally {
232             closeSession(session);
233 
234             FinderCacheUtil.clearCache(ShoppingOrderItem.class.getName());
235         }
236     }
237 
238     public ShoppingOrderItem findByPrimaryKey(long orderItemId)
239         throws NoSuchOrderItemException, SystemException {
240         ShoppingOrderItem shoppingOrderItem = fetchByPrimaryKey(orderItemId);
241 
242         if (shoppingOrderItem == null) {
243             if (_log.isWarnEnabled()) {
244                 _log.warn("No ShoppingOrderItem exists with the primary key " +
245                     orderItemId);
246             }
247 
248             throw new NoSuchOrderItemException(
249                 "No ShoppingOrderItem exists with the primary key " +
250                 orderItemId);
251         }
252 
253         return shoppingOrderItem;
254     }
255 
256     public ShoppingOrderItem fetchByPrimaryKey(long orderItemId)
257         throws SystemException {
258         Session session = null;
259 
260         try {
261             session = openSession();
262 
263             return (ShoppingOrderItem)session.get(ShoppingOrderItemImpl.class,
264                 new Long(orderItemId));
265         }
266         catch (Exception e) {
267             throw processException(e);
268         }
269         finally {
270             closeSession(session);
271         }
272     }
273 
274     public List<ShoppingOrderItem> findByOrderId(long orderId)
275         throws SystemException {
276         boolean finderClassNameCacheEnabled = ShoppingOrderItemModelImpl.CACHE_ENABLED;
277         String finderClassName = ShoppingOrderItem.class.getName();
278         String finderMethodName = "findByOrderId";
279         String[] finderParams = new String[] { Long.class.getName() };
280         Object[] finderArgs = new Object[] { new Long(orderId) };
281 
282         Object result = null;
283 
284         if (finderClassNameCacheEnabled) {
285             result = FinderCacheUtil.getResult(finderClassName,
286                     finderMethodName, finderParams, finderArgs, this);
287         }
288 
289         if (result == null) {
290             Session session = null;
291 
292             try {
293                 session = openSession();
294 
295                 StringBuilder query = new StringBuilder();
296 
297                 query.append(
298                     "FROM com.liferay.portlet.shopping.model.ShoppingOrderItem WHERE ");
299 
300                 query.append("orderId = ?");
301 
302                 query.append(" ");
303 
304                 query.append("ORDER BY ");
305 
306                 query.append("name ASC, ");
307                 query.append("description ASC");
308 
309                 Query q = session.createQuery(query.toString());
310 
311                 QueryPos qPos = QueryPos.getInstance(q);
312 
313                 qPos.add(orderId);
314 
315                 List<ShoppingOrderItem> list = q.list();
316 
317                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
318                     finderClassName, finderMethodName, finderParams,
319                     finderArgs, list);
320 
321                 return list;
322             }
323             catch (Exception e) {
324                 throw processException(e);
325             }
326             finally {
327                 closeSession(session);
328             }
329         }
330         else {
331             return (List<ShoppingOrderItem>)result;
332         }
333     }
334 
335     public List<ShoppingOrderItem> findByOrderId(long orderId, int start,
336         int end) throws SystemException {
337         return findByOrderId(orderId, start, end, null);
338     }
339 
340     public List<ShoppingOrderItem> findByOrderId(long orderId, int start,
341         int end, OrderByComparator obc) throws SystemException {
342         boolean finderClassNameCacheEnabled = ShoppingOrderItemModelImpl.CACHE_ENABLED;
343         String finderClassName = ShoppingOrderItem.class.getName();
344         String finderMethodName = "findByOrderId";
345         String[] finderParams = new String[] {
346                 Long.class.getName(),
347                 
348                 "java.lang.Integer", "java.lang.Integer",
349                 "com.liferay.portal.kernel.util.OrderByComparator"
350             };
351         Object[] finderArgs = new Object[] {
352                 new Long(orderId),
353                 
354                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
355             };
356 
357         Object result = null;
358 
359         if (finderClassNameCacheEnabled) {
360             result = FinderCacheUtil.getResult(finderClassName,
361                     finderMethodName, finderParams, finderArgs, this);
362         }
363 
364         if (result == null) {
365             Session session = null;
366 
367             try {
368                 session = openSession();
369 
370                 StringBuilder query = new StringBuilder();
371 
372                 query.append(
373                     "FROM com.liferay.portlet.shopping.model.ShoppingOrderItem WHERE ");
374 
375                 query.append("orderId = ?");
376 
377                 query.append(" ");
378 
379                 if (obc != null) {
380                     query.append("ORDER BY ");
381                     query.append(obc.getOrderBy());
382                 }
383 
384                 else {
385                     query.append("ORDER BY ");
386 
387                     query.append("name ASC, ");
388                     query.append("description ASC");
389                 }
390 
391                 Query q = session.createQuery(query.toString());
392 
393                 QueryPos qPos = QueryPos.getInstance(q);
394 
395                 qPos.add(orderId);
396 
397                 List<ShoppingOrderItem> list = (List<ShoppingOrderItem>)QueryUtil.list(q,
398                         getDialect(), start, end);
399 
400                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
401                     finderClassName, finderMethodName, finderParams,
402                     finderArgs, list);
403 
404                 return list;
405             }
406             catch (Exception e) {
407                 throw processException(e);
408             }
409             finally {
410                 closeSession(session);
411             }
412         }
413         else {
414             return (List<ShoppingOrderItem>)result;
415         }
416     }
417 
418     public ShoppingOrderItem findByOrderId_First(long orderId,
419         OrderByComparator obc) throws NoSuchOrderItemException, SystemException {
420         List<ShoppingOrderItem> list = findByOrderId(orderId, 0, 1, obc);
421 
422         if (list.size() == 0) {
423             StringBuilder msg = new StringBuilder();
424 
425             msg.append("No ShoppingOrderItem exists with the key {");
426 
427             msg.append("orderId=" + orderId);
428 
429             msg.append(StringPool.CLOSE_CURLY_BRACE);
430 
431             throw new NoSuchOrderItemException(msg.toString());
432         }
433         else {
434             return list.get(0);
435         }
436     }
437 
438     public ShoppingOrderItem findByOrderId_Last(long orderId,
439         OrderByComparator obc) throws NoSuchOrderItemException, SystemException {
440         int count = countByOrderId(orderId);
441 
442         List<ShoppingOrderItem> list = findByOrderId(orderId, count - 1, count,
443                 obc);
444 
445         if (list.size() == 0) {
446             StringBuilder msg = new StringBuilder();
447 
448             msg.append("No ShoppingOrderItem exists with the key {");
449 
450             msg.append("orderId=" + orderId);
451 
452             msg.append(StringPool.CLOSE_CURLY_BRACE);
453 
454             throw new NoSuchOrderItemException(msg.toString());
455         }
456         else {
457             return list.get(0);
458         }
459     }
460 
461     public ShoppingOrderItem[] findByOrderId_PrevAndNext(long orderItemId,
462         long orderId, OrderByComparator obc)
463         throws NoSuchOrderItemException, SystemException {
464         ShoppingOrderItem shoppingOrderItem = findByPrimaryKey(orderItemId);
465 
466         int count = countByOrderId(orderId);
467 
468         Session session = null;
469 
470         try {
471             session = openSession();
472 
473             StringBuilder query = new StringBuilder();
474 
475             query.append(
476                 "FROM com.liferay.portlet.shopping.model.ShoppingOrderItem WHERE ");
477 
478             query.append("orderId = ?");
479 
480             query.append(" ");
481 
482             if (obc != null) {
483                 query.append("ORDER BY ");
484                 query.append(obc.getOrderBy());
485             }
486 
487             else {
488                 query.append("ORDER BY ");
489 
490                 query.append("name ASC, ");
491                 query.append("description ASC");
492             }
493 
494             Query q = session.createQuery(query.toString());
495 
496             QueryPos qPos = QueryPos.getInstance(q);
497 
498             qPos.add(orderId);
499 
500             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
501                     shoppingOrderItem);
502 
503             ShoppingOrderItem[] array = new ShoppingOrderItemImpl[3];
504 
505             array[0] = (ShoppingOrderItem)objArray[0];
506             array[1] = (ShoppingOrderItem)objArray[1];
507             array[2] = (ShoppingOrderItem)objArray[2];
508 
509             return array;
510         }
511         catch (Exception e) {
512             throw processException(e);
513         }
514         finally {
515             closeSession(session);
516         }
517     }
518 
519     public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
520         throws SystemException {
521         Session session = null;
522 
523         try {
524             session = openSession();
525 
526             dynamicQuery.compile(session);
527 
528             return dynamicQuery.list();
529         }
530         catch (Exception e) {
531             throw processException(e);
532         }
533         finally {
534             closeSession(session);
535         }
536     }
537 
538     public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
539         int start, int end) throws SystemException {
540         Session session = null;
541 
542         try {
543             session = openSession();
544 
545             dynamicQuery.setLimit(start, end);
546 
547             dynamicQuery.compile(session);
548 
549             return dynamicQuery.list();
550         }
551         catch (Exception e) {
552             throw processException(e);
553         }
554         finally {
555             closeSession(session);
556         }
557     }
558 
559     public List<ShoppingOrderItem> findAll() throws SystemException {
560         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
561     }
562 
563     public List<ShoppingOrderItem> findAll(int start, int end)
564         throws SystemException {
565         return findAll(start, end, null);
566     }
567 
568     public List<ShoppingOrderItem> findAll(int start, int end,
569         OrderByComparator obc) throws SystemException {
570         boolean finderClassNameCacheEnabled = ShoppingOrderItemModelImpl.CACHE_ENABLED;
571         String finderClassName = ShoppingOrderItem.class.getName();
572         String finderMethodName = "findAll";
573         String[] finderParams = new String[] {
574                 "java.lang.Integer", "java.lang.Integer",
575                 "com.liferay.portal.kernel.util.OrderByComparator"
576             };
577         Object[] finderArgs = new Object[] {
578                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
579             };
580 
581         Object result = null;
582 
583         if (finderClassNameCacheEnabled) {
584             result = FinderCacheUtil.getResult(finderClassName,
585                     finderMethodName, finderParams, finderArgs, this);
586         }
587 
588         if (result == null) {
589             Session session = null;
590 
591             try {
592                 session = openSession();
593 
594                 StringBuilder query = new StringBuilder();
595 
596                 query.append(
597                     "FROM com.liferay.portlet.shopping.model.ShoppingOrderItem ");
598 
599                 if (obc != null) {
600                     query.append("ORDER BY ");
601                     query.append(obc.getOrderBy());
602                 }
603 
604                 else {
605                     query.append("ORDER BY ");
606 
607                     query.append("name ASC, ");
608                     query.append("description ASC");
609                 }
610 
611                 Query q = session.createQuery(query.toString());
612 
613                 List<ShoppingOrderItem> list = null;
614 
615                 if (obc == null) {
616                     list = (List<ShoppingOrderItem>)QueryUtil.list(q,
617                             getDialect(), start, end, false);
618 
619                     Collections.sort(list);
620                 }
621                 else {
622                     list = (List<ShoppingOrderItem>)QueryUtil.list(q,
623                             getDialect(), start, end);
624                 }
625 
626                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
627                     finderClassName, finderMethodName, finderParams,
628                     finderArgs, list);
629 
630                 return list;
631             }
632             catch (Exception e) {
633                 throw processException(e);
634             }
635             finally {
636                 closeSession(session);
637             }
638         }
639         else {
640             return (List<ShoppingOrderItem>)result;
641         }
642     }
643 
644     public void removeByOrderId(long orderId) throws SystemException {
645         for (ShoppingOrderItem shoppingOrderItem : findByOrderId(orderId)) {
646             remove(shoppingOrderItem);
647         }
648     }
649 
650     public void removeAll() throws SystemException {
651         for (ShoppingOrderItem shoppingOrderItem : findAll()) {
652             remove(shoppingOrderItem);
653         }
654     }
655 
656     public int countByOrderId(long orderId) throws SystemException {
657         boolean finderClassNameCacheEnabled = ShoppingOrderItemModelImpl.CACHE_ENABLED;
658         String finderClassName = ShoppingOrderItem.class.getName();
659         String finderMethodName = "countByOrderId";
660         String[] finderParams = new String[] { Long.class.getName() };
661         Object[] finderArgs = new Object[] { new Long(orderId) };
662 
663         Object result = null;
664 
665         if (finderClassNameCacheEnabled) {
666             result = FinderCacheUtil.getResult(finderClassName,
667                     finderMethodName, finderParams, finderArgs, this);
668         }
669 
670         if (result == null) {
671             Session session = null;
672 
673             try {
674                 session = openSession();
675 
676                 StringBuilder query = new StringBuilder();
677 
678                 query.append("SELECT COUNT(*) ");
679                 query.append(
680                     "FROM com.liferay.portlet.shopping.model.ShoppingOrderItem WHERE ");
681 
682                 query.append("orderId = ?");
683 
684                 query.append(" ");
685 
686                 Query q = session.createQuery(query.toString());
687 
688                 QueryPos qPos = QueryPos.getInstance(q);
689 
690                 qPos.add(orderId);
691 
692                 Long count = null;
693 
694                 Iterator<Long> itr = q.list().iterator();
695 
696                 if (itr.hasNext()) {
697                     count = itr.next();
698                 }
699 
700                 if (count == null) {
701                     count = new Long(0);
702                 }
703 
704                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
705                     finderClassName, finderMethodName, finderParams,
706                     finderArgs, count);
707 
708                 return count.intValue();
709             }
710             catch (Exception e) {
711                 throw processException(e);
712             }
713             finally {
714                 closeSession(session);
715             }
716         }
717         else {
718             return ((Long)result).intValue();
719         }
720     }
721 
722     public int countAll() throws SystemException {
723         boolean finderClassNameCacheEnabled = ShoppingOrderItemModelImpl.CACHE_ENABLED;
724         String finderClassName = ShoppingOrderItem.class.getName();
725         String finderMethodName = "countAll";
726         String[] finderParams = new String[] {  };
727         Object[] finderArgs = new Object[] {  };
728 
729         Object result = null;
730 
731         if (finderClassNameCacheEnabled) {
732             result = FinderCacheUtil.getResult(finderClassName,
733                     finderMethodName, finderParams, finderArgs, this);
734         }
735 
736         if (result == null) {
737             Session session = null;
738 
739             try {
740                 session = openSession();
741 
742                 Query q = session.createQuery(
743                         "SELECT COUNT(*) FROM com.liferay.portlet.shopping.model.ShoppingOrderItem");
744 
745                 Long count = null;
746 
747                 Iterator<Long> itr = q.list().iterator();
748 
749                 if (itr.hasNext()) {
750                     count = itr.next();
751                 }
752 
753                 if (count == null) {
754                     count = new Long(0);
755                 }
756 
757                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
758                     finderClassName, finderMethodName, finderParams,
759                     finderArgs, count);
760 
761                 return count.intValue();
762             }
763             catch (Exception e) {
764                 throw processException(e);
765             }
766             finally {
767                 closeSession(session);
768             }
769         }
770         else {
771             return ((Long)result).intValue();
772         }
773     }
774 
775     public void registerListener(ModelListener listener) {
776         List<ModelListener> listeners = ListUtil.fromArray(_listeners);
777 
778         listeners.add(listener);
779 
780         _listeners = listeners.toArray(new ModelListener[listeners.size()]);
781     }
782 
783     public void unregisterListener(ModelListener listener) {
784         List<ModelListener> listeners = ListUtil.fromArray(_listeners);
785 
786         listeners.remove(listener);
787 
788         _listeners = listeners.toArray(new ModelListener[listeners.size()]);
789     }
790 
791     public void afterPropertiesSet() {
792         String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
793                     com.liferay.portal.util.PropsUtil.get(
794                         "value.object.listener.com.liferay.portlet.shopping.model.ShoppingOrderItem")));
795 
796         if (listenerClassNames.length > 0) {
797             try {
798                 List<ModelListener> listeners = new ArrayList<ModelListener>();
799 
800                 for (String listenerClassName : listenerClassNames) {
801                     listeners.add((ModelListener)Class.forName(
802                             listenerClassName).newInstance());
803                 }
804 
805                 _listeners = listeners.toArray(new ModelListener[listeners.size()]);
806             }
807             catch (Exception e) {
808                 _log.error(e);
809             }
810         }
811     }
812 
813     private static Log _log = LogFactory.getLog(ShoppingOrderItemPersistenceImpl.class);
814     private ModelListener[] _listeners = new ModelListener[0];
815 }