001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.commons.beanutils;
018
019 import java.util.ArrayList;
020 import java.util.Map;
021 import java.util.Collection;
022 import java.util.Iterator;
023 import java.lang.reflect.Array;
024
025 /**
026 * <h2><i>Lazy</i> DynaBean List.</h2>
027 *
028 * <p>There are two main purposes for this class:</p>
029 * <ul>
030 * <li>To provide <i>Lazy List</i> behaviour - automatically
031 * <i>growing</i> and <i>populating</i> the <code>List</code>
032 * with either <code>DynaBean</code>, <code>java.util.Map</code>
033 * or POJO Beans.</li>
034 * <li>To provide a straight forward way of putting a Collection
035 * or Array into the lazy list <i>and</i> a straight forward
036 * way to get it out again at the end.</li>
037 * </ul>
038 *
039 * <p>All elements added to the List are stored as <code>DynaBean</code>'s:</p>
040 * <ul>
041 * <li><code>java.util.Map</code> elements are "wrapped" in a <code>LazyDynaMap</code>.</i>
042 * <li>POJO Bean elements are "wrapped" in a <code>WrapDynaBean.</code></i>
043 * <li><code>DynaBean</code>'s are stored un-changed.</i>
044 * </ul>
045 *
046 * <h4><code>toArray()</code></h4>
047 * <p>The <code>toArray()</code> method returns an array of the
048 * elements of the appropriate type. If the <code>LazyDynaList</code>
049 * is populated with <code>java.util.Map</code> objects a
050 * <code>Map[]</code> array is returned.
051 * If the list is populated with POJO Beans an appropriate
052 * array of the POJO Beans is returned. Otherwise a <code>DynaBean[]</code>
053 * array is returned.
054 * </p>
055 *
056 * <h4><code>toDynaBeanArray()</code></h4>
057 * <p>The <code>toDynaBeanArray()</code> method returns a
058 * <code>DynaBean[]</code> array of the elements in the List.
059 * </p>
060 *
061 * <p><strong>N.B.</strong>All the elements in the List must be the
062 * same type. If the <code>DynaClass</code> or <code>Class</code>
063 * of the <code>LazyDynaList</code>'s elements is
064 * not specified, then it will be automatically set to the type
065 * of the first element populated.
066 * </p>
067 *
068 * <h3>Example 1</h3>
069 * <p>If you have an array of <code>java.util.Map[]</code> - you can put that into
070 * a <code>LazyDynaList</code>.</p>
071 *
072 * <pre><code>
073 * TreeMap[] myArray = .... // your Map[]
074 * List lazyList = new LazyDynaList(myArray);
075 * </code></pre>
076 *
077 * <p>New elements of the appropriate Map type are
078 * automatically populated:</p>
079 *
080 * <pre><code>
081 * // get(index) automatically grows the list
082 * DynaBean newElement = (DynaBean)lazyList.get(lazyList.size());
083 * newElement.put("someProperty", "someValue");
084 * </code></pre>
085 *
086 * <p>Once you've finished you can get back an Array of the
087 * elements of the appropriate type:</p>
088 *
089 * <pre><code>
090 * // Retrieve the array from the list
091 * TreeMap[] myArray = (TreeMap[])lazyList.toArray());
092 * </code></pre>
093 *
094 *
095 * <h3>Example 2</h3>
096 * <p>Alternatively you can create an <i>empty</i> List and
097 * specify the Class for List's elements. The LazyDynaList
098 * uses the Class to automatically populate elements:</p>
099 *
100 * <pre><code>
101 * // e.g. For Maps
102 * List lazyList = new LazyDynaList(TreeMap.class);
103 *
104 * // e.g. For POJO Beans
105 * List lazyList = new LazyDynaList(MyPojo.class);
106 *
107 * // e.g. For DynaBeans
108 * List lazyList = new LazyDynaList(MyDynaBean.class);
109 * </code></pre>
110 *
111 * <h3>Example 3</h3>
112 * <p>Alternatively you can create an <i>empty</i> List and specify the
113 * DynaClass for List's elements. The LazyDynaList uses
114 * the DynaClass to automatically populate elements:</p>
115 *
116 * <pre><code>
117 * // e.g. For Maps
118 * DynaClass dynaClass = new LazyDynaMap(new HashMap());
119 * List lazyList = new LazyDynaList(dynaClass);
120 *
121 * // e.g. For POJO Beans
122 * DynaClass dynaClass = (new WrapDynaBean(myPojo)).getDynaClass();
123 * List lazyList = new LazyDynaList(dynaClass);
124 *
125 * // e.g. For DynaBeans
126 * DynaClass dynaClass = new BasicDynaClass(properties);
127 * List lazyList = new LazyDynaList(dynaClass);
128 * </code></pre>
129 *
130 * <p><strong>N.B.</strong> You may wonder why control the type
131 * using a <code>DynaClass</code> rather than the <code>Class</code>
132 * as in the previous example - the reason is that some <code>DynaBean</code>
133 * implementations don't have a <i>default</i> empty constructor and
134 * therefore need to be instantiated using the <code>DynaClass.newInstance()</code>
135 * method.</p>
136 *
137 * <h3>Example 4</h3>
138 * <p>A slight variation - set the element type using either
139 * the <code>setElementType(Class)</code> method or the
140 * <code>setElementDynaClass(DynaClass)</code> method - then populate
141 * with the normal <code>java.util.List</code> methods(i.e.
142 * <code>add()</code>, <code>addAll()</code> or <code>set()</code>).</p>
143 *
144 * <pre><code>
145 * // Create a new LazyDynaList (100 element capacity)
146 * LazyDynaList lazyList = new LazyDynaList(100);
147 *
148 * // Either Set the element type...
149 * lazyList.setElementType(TreeMap.class);
150 *
151 * // ...or the element DynaClass...
152 * lazyList.setElementDynaClass(new MyCustomDynaClass());
153 *
154 * // Populate from a collection
155 * lazyList.addAll(myCollection);
156 *
157 * </code></pre>
158 *
159 * @author Niall Pemberton
160 * @version $Revision: 926529 $ $Date: 2010-03-23 11:44:24 +0000 (Tue, 23 Mar 2010) $
161 * @since 1.8.0
162 */
163 public class LazyDynaList extends ArrayList {
164
165 /**
166 * The DynaClass of the List's elements.
167 */
168 private DynaClass elementDynaClass;
169
170 /**
171 * The WrapDynaClass if the List's contains
172 * POJO Bean elements.
173 *
174 * N.B. WrapDynaClass isn't serlializable, which
175 * is why its stored separately in a
176 * transient instance variable.
177 */
178 private transient WrapDynaClass wrapDynaClass;
179
180 /**
181 * The type of the List's elements.
182 */
183 private Class elementType;
184
185 /**
186 * The DynaBean type of the List's elements.
187 */
188 private Class elementDynaBeanType;
189
190
191 // ------------------- Constructors ------------------------------
192
193 /**
194 * Default Constructor.
195 */
196 public LazyDynaList() {
197 super();
198 }
199
200 /**
201 * Construct a LazyDynaList with the
202 * specified capacity.
203 *
204 * @param capacity The initial capacity of the list.
205 */
206 public LazyDynaList(int capacity) {
207 super(capacity);
208
209 }
210
211 /**
212 * Construct a LazyDynaList with a
213 * specified DynaClass for its elements.
214 *
215 * @param elementDynaClass The DynaClass of the List's elements.
216 */
217 public LazyDynaList(DynaClass elementDynaClass) {
218 super();
219 setElementDynaClass(elementDynaClass);
220 }
221
222 /**
223 * Construct a LazyDynaList with a
224 * specified type for its elements.
225 *
226 * @param elementType The Type of the List's elements.
227 */
228 public LazyDynaList(Class elementType) {
229 super();
230 setElementType(elementType);
231 }
232
233 /**
234 * Construct a LazyDynaList populated with the
235 * elements of a Collection.
236 *
237 * @param collection The Collection to poulate the List from.
238 */
239 public LazyDynaList(Collection collection) {
240 super(collection.size());
241 addAll(collection);
242 }
243
244 /**
245 * Construct a LazyDynaList populated with the
246 * elements of an Array.
247 *
248 * @param array The Array to poulate the List from.
249 */
250 public LazyDynaList(Object[] array) {
251 super(array.length);
252 for (int i = 0; i < array.length; i++) {
253 add(array[i]);
254 }
255 }
256
257
258 // ------------------- java.util.List Methods --------------------
259
260 /**
261 * <p>Insert an element at the specified index position.</p>
262 *
263 * <p>If the index position is greater than the current
264 * size of the List, then the List is automatically
265 * <i>grown</i> to the appropriate size.</p>
266 *
267 * @param index The index position to insert the new element.
268 * @param element The new element to add.
269 */
270 public void add(int index, Object element) {
271
272 DynaBean dynaBean = transform(element);
273
274 growList(index);
275
276 super.add(index, dynaBean);
277
278 }
279
280 /**
281 * <p>Add an element to the List.</p>
282 *
283 * @param element The new element to add.
284 * @return true.
285 */
286 public boolean add(Object element) {
287
288 DynaBean dynaBean = transform(element);
289
290 return super.add(dynaBean);
291
292 }
293
294 /**
295 * <p>Add all the elements from a Collection to the list.
296 *
297 * @param collection The Collection of new elements.
298 * @return true if elements were added.
299 */
300 public boolean addAll(Collection collection) {
301
302 if (collection == null || collection.size() == 0) {
303 return false;
304 }
305
306 ensureCapacity(size() + collection.size());
307
308 Iterator iterator = collection.iterator();
309 while (iterator.hasNext()) {
310 add(iterator.next());
311 }
312
313 return true;
314
315 }
316
317 /**
318 * <p>Insert all the elements from a Collection into the
319 * list at a specified position.
320 *
321 * <p>If the index position is greater than the current
322 * size of the List, then the List is automatically
323 * <i>grown</i> to the appropriate size.</p>
324 *
325 * @param collection The Collection of new elements.
326 * @param index The index position to insert the new elements at.
327 * @return true if elements were added.
328 */
329 public boolean addAll(int index, Collection collection) {
330
331 if (collection == null || collection.size() == 0) {
332 return false;
333 }
334
335 ensureCapacity((index > size() ? index : size()) + collection.size());
336
337 // Call "tranform" with first element, before
338 // List is "grown" to ensure the correct DynaClass
339 // is set.
340 if (size() == 0) {
341 transform(collection.iterator().next());
342 }
343
344 growList(index);
345
346 Iterator iterator = collection.iterator();
347 while (iterator.hasNext()) {
348 add(index++, iterator.next());
349 }
350
351 return true;
352
353 }
354
355 /**
356 * <p>Return the element at the specified position.</p>
357 *
358 * <p>If the position requested is greater than the current
359 * size of the List, then the List is automatically
360 * <i>grown</i> (and populated) to the appropriate size.</p>
361 *
362 * @param index The index position to insert the new elements at.
363 * @return The element at the specified position.
364 */
365 public Object get(int index) {
366
367 growList(index + 1);
368
369 return super.get(index);
370
371 }
372
373 /**
374 * <p>Set the element at the specified position.</p>
375 *
376 * <p>If the position requested is greater than the current
377 * size of the List, then the List is automatically
378 * <i>grown</i> (and populated) to the appropriate size.</p>
379 *
380 * @param index The index position to insert the new element at.
381 * @param element The new element.
382 * @return The new element.
383 */
384 public Object set(int index, Object element) {
385
386 DynaBean dynaBean = transform(element);
387
388 growList(index + 1);
389
390 return super.set(index, dynaBean);
391
392 }
393
394 /**
395 * <p>Converts the List to an Array.</p>
396 *
397 * <p>The type of Array created depends on the contents
398 * of the List:</p>
399 * <ul>
400 * <li>If the List contains only LazyDynaMap type elements
401 * then a java.util.Map[] array will be created.</li>
402 * <li>If the List contains only elements which are
403 * "wrapped" DynaBeans then an Object[] of the most
404 * suitable type will be created.</li>
405 * <li>...otherwise a DynaBean[] will be created.</li>
406 *
407 * @return An Array of the elements in this List.
408 */
409 public Object[] toArray() {
410
411 if (size() == 0 && elementType == null) {
412 return new LazyDynaBean[0];
413 }
414
415 Object[] array = (Object[])Array.newInstance(elementType, size());
416 for (int i = 0; i < size(); i++) {
417 if (Map.class.isAssignableFrom(elementType)) {
418 array[i] = ((LazyDynaMap)get(i)).getMap();
419 } else if (DynaBean.class.isAssignableFrom(elementType)) {
420 array[i] = get(i);
421 } else {
422 array[i] = ((WrapDynaBean)get(i)).getInstance();
423 }
424 }
425 return array;
426
427 }
428
429 /**
430 * <p>Converts the List to an Array of the specified type.</p>
431 *
432 * @param model The model for the type of array to return
433 * @return An Array of the elements in this List.
434 */
435 public Object[] toArray(Object[] model) {
436
437 // Allocate the Array
438 Class arrayType = model.getClass().getComponentType();
439 Object[] array = (Object[])Array.newInstance(arrayType, size());
440
441 if (size() == 0 && elementType == null) {
442 return new LazyDynaBean[0];
443 }
444
445 if ((DynaBean.class.isAssignableFrom(arrayType))) {
446 for (int i = 0; i < size(); i++) {
447 array[i] = get(i);
448 }
449 return array;
450 }
451
452 if ((arrayType.isAssignableFrom(elementType))) {
453 for (int i = 0; i < size(); i++) {
454 if (Map.class.isAssignableFrom(elementType)) {
455 array[i] = ((LazyDynaMap)get(i)).getMap();
456 } else if (DynaBean.class.isAssignableFrom(elementType)) {
457 array[i] = get(i);
458 } else {
459 array[i] = ((WrapDynaBean)get(i)).getInstance();
460 }
461 }
462 return array;
463 }
464
465 throw new IllegalArgumentException("Invalid array type: "
466 + arrayType.getName() + " - not compatible with '"
467 + elementType.getName());
468
469 }
470
471
472 // ------------------- Public Methods ----------------------------
473
474 /**
475 * <p>Converts the List to an DynaBean Array.</p>
476 *
477 * @return A DynaBean[] of the elements in this List.
478 */
479 public DynaBean[] toDynaBeanArray() {
480
481 if (size() == 0 && elementDynaBeanType == null) {
482 return new LazyDynaBean[0];
483 }
484
485 DynaBean[] array = (DynaBean[])Array.newInstance(elementDynaBeanType, size());
486 for (int i = 0; i < size(); i++) {
487 array[i] = (DynaBean)get(i);
488 }
489 return array;
490
491 }
492
493 /**
494 * <p>Set the element Type and DynaClass.</p>
495 *
496 * @param elementType The type of the elements.
497 * @exception IllegalArgumentException if the List already
498 * contains elements or the DynaClass is null.
499 */
500 public void setElementType(Class elementType) {
501
502 if (elementType == null) {
503 throw new IllegalArgumentException("Element Type is missing");
504 }
505
506 boolean changeType = (this.elementType != null && !this.elementType.equals(elementType));
507 if (changeType && size() > 0) {
508 throw new IllegalStateException("Element Type cannot be reset");
509 }
510
511 this.elementType = elementType;
512
513 // Create a new object of the specified type
514 Object object = null;
515 try {
516 object = elementType.newInstance();
517 } catch (Exception e) {
518 throw new IllegalArgumentException("Error creating type: "
519 + elementType.getName() + " - " + e);
520 }
521
522 // Create a DynaBean
523 DynaBean dynaBean = null;
524 if (Map.class.isAssignableFrom(elementType)) {
525 dynaBean = new LazyDynaMap((Map)object);
526 this.elementDynaClass = dynaBean.getDynaClass();
527 } else if (DynaBean.class.isAssignableFrom(elementType)) {
528 dynaBean = (DynaBean)object;
529 this.elementDynaClass = dynaBean.getDynaClass();
530 } else {
531 dynaBean = new WrapDynaBean(object);
532 this.wrapDynaClass = (WrapDynaClass)dynaBean.getDynaClass();
533 }
534
535 this.elementDynaBeanType = dynaBean.getClass();
536
537 // Re-calculate the type
538 if (WrapDynaBean.class.isAssignableFrom(elementDynaBeanType )) {
539 this.elementType = ((WrapDynaBean)dynaBean).getInstance().getClass();
540 } else if (LazyDynaMap.class.isAssignableFrom(elementDynaBeanType )) {
541 this.elementType = ((LazyDynaMap)dynaBean).getMap().getClass();
542 }
543
544 }
545
546 /**
547 * <p>Set the element Type and DynaClass.</p>
548 *
549 * @param elementDynaClass The DynaClass of the elements.
550 * @exception IllegalArgumentException if the List already
551 * contains elements or the DynaClass is null.
552 */
553 public void setElementDynaClass(DynaClass elementDynaClass) {
554
555 if (elementDynaClass == null) {
556 throw new IllegalArgumentException("Element DynaClass is missing");
557 }
558
559 if (size() > 0) {
560 throw new IllegalStateException("Element DynaClass cannot be reset");
561 }
562
563 // Try to create a new instance of the DynaBean
564 try {
565 DynaBean dynaBean = elementDynaClass.newInstance();
566 this.elementDynaBeanType = dynaBean.getClass();
567 if (WrapDynaBean.class.isAssignableFrom(elementDynaBeanType)) {
568 this.elementType = ((WrapDynaBean)dynaBean).getInstance().getClass();
569 this.wrapDynaClass = (WrapDynaClass)elementDynaClass;
570 } else if (LazyDynaMap.class.isAssignableFrom(elementDynaBeanType)) {
571 this.elementType = ((LazyDynaMap)dynaBean).getMap().getClass();
572 this.elementDynaClass = elementDynaClass;
573 } else {
574 this.elementType = dynaBean.getClass();
575 this.elementDynaClass = elementDynaClass;
576 }
577 } catch (Exception e) {
578 throw new IllegalArgumentException(
579 "Error creating DynaBean from " +
580 elementDynaClass.getClass().getName() + " - " + e);
581 }
582
583 }
584
585
586 // ------------------- Private Methods ---------------------------
587
588 /**
589 * <p>Automatically <i>grown</i> the List
590 * to the appropriate size, populating with
591 * DynaBeans.</p>
592 *
593 * @param requiredSize the required size of the List.
594 */
595 private void growList(int requiredSize) {
596
597 if (requiredSize < size()) {
598 return;
599 }
600
601 ensureCapacity(requiredSize + 1);
602
603 for (int i = size(); i < requiredSize; i++) {
604 DynaBean dynaBean = transform(null);
605 super.add(dynaBean);
606 }
607
608 }
609
610 /**
611 * <p>Transform the element into a DynaBean:</p>
612 *
613 * <ul>
614 * <li>Map elements are turned into LazyDynaMap's.</li>
615 * <li>POJO Beans are "wrapped" in a WrapDynaBean.</li>
616 * <li>DynaBeans are unchanged.</li>
617 * </li>
618 *
619 * @param element The element to transformt.
620 * @param The DynaBean to store in the List.
621 */
622 private DynaBean transform(Object element) {
623
624 DynaBean dynaBean = null;
625 Class newDynaBeanType = null;
626 Class newElementType = null;
627
628 // Create a new element
629 if (element == null) {
630
631 // Default Types to LazyDynaBean
632 // if not specified
633 if (elementType == null) {
634 setElementDynaClass(new LazyDynaClass());
635 }
636
637 // Get DynaClass (restore WrapDynaClass lost in serialization)
638 if (getDynaClass() == null) {
639 setElementType(elementType);
640 }
641
642 // Create a new DynaBean
643 try {
644 dynaBean = getDynaClass().newInstance();
645 newDynaBeanType = dynaBean.getClass();
646 } catch (Exception e) {
647 throw new IllegalArgumentException("Error creating DynaBean: "
648 + getDynaClass().getClass().getName()
649 + " - " + e);
650 }
651
652 } else {
653
654 // Transform Object to a DynaBean
655 newElementType = element.getClass();
656 if (Map.class.isAssignableFrom(element.getClass())) {
657 dynaBean = new LazyDynaMap((Map)element);
658 } else if (DynaBean.class.isAssignableFrom(element.getClass())) {
659 dynaBean = (DynaBean)element;
660 } else {
661 dynaBean = new WrapDynaBean(element);
662 }
663
664 newDynaBeanType = dynaBean.getClass();
665
666 }
667
668 // Re-calculate the element type
669 newElementType = dynaBean.getClass();
670 if (WrapDynaBean.class.isAssignableFrom(newDynaBeanType)) {
671 newElementType = ((WrapDynaBean)dynaBean).getInstance().getClass();
672 } else if (LazyDynaMap.class.isAssignableFrom(newDynaBeanType)) {
673 newElementType = ((LazyDynaMap)dynaBean).getMap().getClass();
674 }
675
676 // Check the new element type, matches all the
677 // other elements in the List
678 if (elementType != null && !newElementType.equals(elementType)) {
679 throw new IllegalArgumentException("Element Type " + newElementType
680 + " doesn't match other elements " + elementType);
681 }
682
683 return dynaBean;
684
685 }
686
687 /**
688 * Return the DynaClass.
689 */
690 private DynaClass getDynaClass() {
691 return (elementDynaClass == null ? wrapDynaClass : elementDynaClass);
692 }
693 }