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);
add
public boolean add(Object element)
Add an element to the List.
element
- The new element to add.
add
public void add(int index,
Object element)
Insert an element at the specified index position.
If the index position is greater than the current
size of the List, then the List is automatically
grown to the appropriate size.
index
- The index position to insert the new element.element
- The new element to add.
addAll
public boolean addAll(Collection collection)
Add all the elements from a Collection to the list.
collection
- The Collection of new elements.
- true if elements were added.
addAll
public boolean addAll(int index,
Collection collection)
Insert all the elements from a Collection into the
list at a specified position.
If the index position is greater than the current
size of the List, then the List is automatically
grown to the appropriate size.
index
- The index position to insert the new elements at.collection
- The Collection of new elements.
- true if elements were added.
get
public Object get(int index)
Return the element at the specified position.
If the position requested is greater than the current
size of the List, then the List is automatically
grown (and populated) to the appropriate size.
index
- The index position to insert the new elements at.
- The element at the specified position.
growList
private void growList(int requiredSize)
Automatically grown the List
to the appropriate size, populating with
DynaBeans.
requiredSize
- the required size of the List.
set
public Object set(int index,
Object element)
Set the element at the specified position.
If the position requested is greater than the current
size of the List, then the List is automatically
grown (and populated) to the appropriate size.
index
- The index position to insert the new element at.element
- The new element.
setElementDynaClass
public void setElementDynaClass(DynaClass elementDynaClass)
Set the element Type and DynaClass.
elementDynaClass
- The DynaClass of the elements.
setElementType
public void setElementType(Class elementType)
Set the element Type and DynaClass.
elementType
- The type of the elements.
toArray
public Object[] toArray()
Converts the List to an Array.
The type of Array created depends on the contents
of the List:
- If the List contains only LazyDynaMap type elements
then a java.util.Map[] array will be created.
- If the List contains only elements which are
"wrapped" DynaBeans then an Object[] of the most
suitable type will be created.
- ...otherwise a DynaBean[] will be created.
- An Array of the elements in this List.
toArray
public Object[] toArray(Object[] model)
Converts the List to an Array of the specified type.
model
- The model for the type of array to return
- An Array of the elements in this List.
toDynaBeanArray
public DynaBean[] toDynaBeanArray()
Converts the List to an DynaBean Array.
- A DynaBean[] of the elements in this List.
transform
private DynaBean transform(Object element)
Transform the element into a DynaBean:
- Map elements are turned into LazyDynaMap's.
- POJO Beans are "wrapped" in a WrapDynaBean.
- DynaBeans are unchanged.
element
- The element to transformt.