Lazy DynaBean List.
There are two main purposes for this class:
- To provide Lazy List behaviour - automatically
growing and populating the
List
with either DynaBean, java.util.Map
or POJO Beans.
- To provide a straight forward way of putting a Collection
or Array into the lazy list and a straight forward
way to get it out again at the end.
All elements added to the List are stored as DynaBean's:
java.util.Map elements are "wrapped" in a LazyDynaMap.
- POJO Bean elements are "wrapped" in a
WrapDynaBean.
DynaBean's are stored un-changed.
toArray()
The toArray() method returns an array of the
elements of the appropriate type. If the LazyDynaList
is populated with java.util.Map objects a
Map[] array is returned.
If the list is populated with POJO Beans an appropriate
array of the POJO Beans is returned. Otherwise a DynaBean[]
array is returned.
toDynaBeanArray()
The toDynaBeanArray() method returns a
DynaBean[] array of the elements in the List.
N.B.All the elements in the List must be the
same type. If the DynaClass or Class
of the LazyDynaList's elements is
not specified, then it will be automatically set to the type
of the first element populated.
Example 1
If you have an array of java.util.Map[] - you can put that into
a LazyDynaList.
TreeMap[] myArray = .... // your Map[]
List lazyList = new LazyDynaList(myArray);
New elements of the appropriate Map type are
automatically populated:
// get(index) automatically grows the list
DynaBean newElement = (DynaBean)lazyList.get(lazyList.size());
newElement.put("someProperty", "someValue");
Once you've finished you can get back an Array of the
elements of the appropriate type:
// Retrieve the array from the list
TreeMap[] myArray = (TreeMap[])lazyList.toArray());
Example 2
Alternatively you can create an empty List and
specify the Class for List's elements. The LazyDynaList
uses the Class to automatically populate elements:
// e.g. For Maps
List lazyList = new LazyDynaList(TreeMap.class);
// e.g. For POJO Beans
List lazyList = new LazyDynaList(MyPojo.class);
// e.g. For DynaBeans
List lazyList = new LazyDynaList(MyDynaBean.class);
Example 3
Alternatively you can create an empty List and specify the
DynaClass for List's elements. The LazyDynaList uses
the DynaClass to automatically populate elements:
// e.g. For Maps
DynaClass dynaClass = new LazyDynaMap(new HashMap());
List lazyList = new LazyDynaList(dynaClass);
// e.g. For POJO Beans
DynaClass dynaClass = (new WrapDynaBean(myPojo)).getDynaClass();
List lazyList = new LazyDynaList(dynaClass);
// e.g. For DynaBeans
DynaClass dynaClass = new BasicDynaClass(properties);
List lazyList = new LazyDynaList(dynaClass);
N.B. You may wonder why control the type
using a DynaClass rather than the Class
as in the previous example - the reason is that some DynaBean
implementations don't have a default empty constructor and
therefore need to be instantiated using the DynaClass.newInstance()
method.
Example 4
A slight variation - set the element type using either
the setElementType(Class) method or the
setElementDynaClass(DynaClass) method - then populate
with the normal java.util.List methods(i.e.
add(), addAll() or set()).
// Create a new LazyDynaList (100 element capacity)
LazyDynaList lazyList = new LazyDynaList(100);
// Either Set the element type...
lazyList.setElementType(TreeMap.class);
// ...or the element DynaClass...
lazyList.setElementDynaClass(new MyCustomDynaClass());
// Populate from a collection
lazyList.addAll(myCollection);
author:
Niall Pemberton
version:
$Revision: 555824 $ $Date: 2007-07-13 01:27:15 +0100 (Fri, 13 Jul 2007) $ | 