com.feilong.lib.beanutils.LazyDynaMap Maven / Gradle / Ivy
Show all versions of feilong Show documentation
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.feilong.lib.beanutils;
import java.util.Map;
import org.apache.commons.beanutils.DynaBean;
/**
*
* Provides a light weight DynaBean facade to a Map
* with lazy map/list processing.
*
*
*
* Its a light weight DynaBean implementation because there is no
* actual DynaClass associated with this DynaBean - in fact
* it implements the DynaClass interface itself providing pseudo DynaClass
* behaviour from the actual values stored in the Map.
*
*
*
* As well providing rhe standard DynaBean access to the Map's properties
* this class also provides the usual Lazy behaviour:
*
*
* - Properties don't need to be pre-defined in a
DynaClass
* - Indexed properties (
Lists or Arrays) are automatically instantiated
* and grown so that they are large enough to cater for the index being set.
* - Mapped properties are automatically instantiated.
*
*
*
* Restricted DynaClass
*
*
* This class implements the MutableDynaClass interface.
* MutableDynaClass have a facility to restrict the DynaClass
* so that its properties cannot be modified. If the MutableDynaClass is
* restricted then calling any of the set() methods for a property which
* doesn't exist will result in a IllegalArgumentException being thrown.
*
*
* @version $Id$
*/
public class LazyDynaMap extends LazyDynaBean implements MutableDynaClass{
/**
*
*/
private static final long serialVersionUID = 3716232872185167024L;
/**
* The name of this DynaClass (analogous to the
* getName() method of java.lang.Class).
*/
protected String name;
/**
* Controls whether changes to this DynaClass's properties are allowed.
*/
protected boolean restricted;
/**
*
* Controls whether the getDynaProperty() method returns
* null if a property doesn't exist - or creates a new one.
*
*
*
* Default is false.
*/
protected boolean returnNull = false;
// ------------------- Constructors ----------------------------------
/**
* Default Constructor.
*/
public LazyDynaMap(){
this(null, (Map) null);
}
/**
* Construct a new LazyDynaMap with the specified name.
*
* @param name
* Name of this DynaBean class
*/
public LazyDynaMap(final String name){
this(name, (Map) null);
}
/**
* Construct a new LazyDynaMap with the specified Map.
*
* @param values
* The Map backing this LazyDynaMap
*/
public LazyDynaMap(final Map values){
this(null, values);
}
/**
* Construct a new LazyDynaMap with the specified name and Map.
*
* @param name
* Name of this DynaBean class
* @param values
* The Map backing this LazyDynaMap
*/
public LazyDynaMap(final String name, final Map values){
this.name = name == null ? "LazyDynaMap" : name;
this.values = values == null ? newMap() : values;
this.dynaClass = this;
}
/**
* Construct a new LazyDynaMap with the specified properties.
*
* @param properties
* Property descriptors for the supported properties
*/
public LazyDynaMap(final DynaProperty[] properties){
this(null, properties);
}
/**
* Construct a new LazyDynaMap with the specified name and properties.
*
* @param name
* Name of this DynaBean class
* @param properties
* Property descriptors for the supported properties
*/
public LazyDynaMap(final String name, final DynaProperty[] properties){
this(name, (Map) null);
if (properties != null){
for (DynaProperty propertie : properties){
add(propertie);
}
}
}
/**
* Construct a new LazyDynaMap based on an exisiting DynaClass
*
* @param dynaClass
* DynaClass to copy the name and properties from
*/
public LazyDynaMap(final DynaClass dynaClass){
this(dynaClass.getName(), dynaClass.getDynaProperties());
}
// ------------------- Public Methods ----------------------------------
/**
* Set the Map backing this DynaBean
*
* @param values
* The new Map of values
*/
public void setMap(final Map values){
this.values = values;
}
/**
* Return the underlying Map backing this DynaBean
*
* @return the underlying Map
* @since 1.8.0
*/
@Override
public Map getMap(){
return values;
}
// ------------------- DynaBean Methods ----------------------------------
/**
* Set the value of a simple property with the specified name.
*
* @param name
* Name of the property whose value is to be set
* @param value
* Value to which this property is to be set
*/
@Override
public void set(final String name,final Object value){
if (isRestricted() && !values.containsKey(name)){
throw new IllegalArgumentException("Invalid property name '" + name + "' (DynaClass is restricted)");
}
values.put(name, value);
}
// ------------------- DynaClass Methods ----------------------------------
/**
* Return the name of this DynaClass (analogous to the
* getName() method of java.lang.Class)
*
* @return the name of the DynaClass
*/
@Override
public String getName(){
return this.name;
}
/**
*
* Return a property descriptor for the specified property.
*
*
*
* If the property is not found and the returnNull indicator is
* true, this method always returns null.
*
*
*
* If the property is not found and the returnNull indicator is
* false a new property descriptor is created and returned (although
* its not actually added to the DynaClass's properties). This is the default
* beahviour.
*
*
*
* The reason for not returning a null property descriptor is that
* BeanUtils uses this method to check if a property exists
* before trying to set it - since these Map implementations automatically
* add any new properties when they are set, returning null from
* this method would defeat their purpose.
*
*
* @param name
* Name of the dynamic property for which a descriptor
* is requested
* @return The descriptor for the specified property
*
* @throws IllegalArgumentException
* if no property name is specified
*/
@Override
public DynaProperty getDynaProperty(final String name){
if (name == null){
throw new IllegalArgumentException("Property name is missing.");
}
// If it doesn't exist and returnNull is false
// create a new DynaProperty
if (!values.containsKey(name) && isReturnNull()){
return null;
}
final Object value = values.get(name);
if (value == null){
return new DynaProperty(name);
}else{
return new DynaProperty(name, value.getClass());
}
}
/**
*
* Return an array of ProperyDescriptors for the properties
* currently defined in this DynaClass. If no properties are defined, a
* zero-length array will be returned.
*
*
*
* FIXME - Should we really be implementing
* getBeanInfo() instead, which returns property descriptors
* and a bunch of other stuff?
*
*
* @return the set of properties for this DynaClass
*/
@Override
public DynaProperty[] getDynaProperties(){
int i = 0;
final DynaProperty[] properties = new DynaProperty[values.size()];
for (final Map.Entry e : values.entrySet()){
final String name = e.getKey();
final Object value = values.get(name);
properties[i++] = new DynaProperty(name, value == null ? null : value.getClass());
}
return properties;
}
/**
* Instantiate and return a new DynaBean instance, associated
* with this DynaClass.
*
* @return A new DynaBean instance
*/
@Override
public DynaBean newInstance(){
// Create a new instance of the Map
Map newMap = null;
try{
@SuppressWarnings("unchecked")
final
// The new map is used as properties map
Map temp = getMap().getClass().newInstance();
newMap = temp;
}catch (final Exception ex){
newMap = newMap();
}
// Crate new LazyDynaMap and initialize properties
final LazyDynaMap lazyMap = new LazyDynaMap(newMap);
final DynaProperty[] properties = this.getDynaProperties();
if (properties != null){
for (DynaProperty propertie : properties){
lazyMap.add(propertie);
}
}
return lazyMap;
}
// ------------------- MutableDynaClass Methods ----------------------------------
/**
*
* Is this DynaClass currently restricted.
*
*
* If restricted, no changes to the existing registration of
* property names, data types, readability, or writeability are allowed.
*
*
* @return true if this Mutable {@link DynaClass} is restricted,
* otherwise false
*/
@Override
public boolean isRestricted(){
return restricted;
}
/**
*
* Set whether this DynaClass is currently restricted.
*
*
* If restricted, no changes to the existing registration of
* property names, data types, readability, or writeability are allowed.
*
*
* @param restricted
* The new restricted state
*/
@Override
public void setRestricted(final boolean restricted){
this.restricted = restricted;
}
/**
* Add a new dynamic property with no restrictions on data type,
* readability, or writeability.
*
* @param name
* Name of the new dynamic property
*
* @throws IllegalArgumentException
* if name is null
*/
@Override
public void add(final String name){
add(name, null);
}
/**
* Add a new dynamic property with the specified data type, but with
* no restrictions on readability or writeability.
*
* @param name
* Name of the new dynamic property
* @param type
* Data type of the new dynamic property (null for no
* restrictions)
*
* @throws IllegalArgumentException
* if name is null
* @throws IllegalStateException
* if this DynaClass is currently
* restricted, so no new properties can be added
*/
@Override
public void add(final String name,final Class type){
if (name == null){
throw new IllegalArgumentException("Property name is missing.");
}
if (isRestricted()){
throw new IllegalStateException("DynaClass is currently restricted. No new properties can be added.");
}
final Object value = values.get(name);
// Check if the property already exists
if (value == null){
values.put(name, type == null ? null : createProperty(name, type));
}
}
/**
*
* Add a new dynamic property with the specified data type, readability,
* and writeability.
*
*
*
* N.B.Support for readable/writeable properties has not been implemented
* and this method always throws a UnsupportedOperationException.
*
*
*
* I'm not sure the intention of the original authors for this method, but it seems to
* me that readable/writable should be attributes of the DynaProperty class
* (which they are not) and is the reason this method has not been implemented.
*
*
* @param name
* Name of the new dynamic property
* @param type
* Data type of the new dynamic property (null for no
* restrictions)
* @param readable
* Set to true if this property value
* should be readable
* @param writeable
* Set to true if this property value
* should be writeable
*
* @throws UnsupportedOperationException
* anytime this method is called
*/
@Override
public void add(final String name,final Class type,final boolean readable,final boolean writeable){
throw new java.lang.UnsupportedOperationException("readable/writable properties not supported");
}
/**
* Add a new dynamic property.
*
* @param property
* Property the new dynamic property to add.
*
* @throws IllegalArgumentException
* if name is null
*/
protected void add(final DynaProperty property){
add(property.getName(), property.getType());
}
/**
* Remove the specified dynamic property, and any associated data type,
* readability, and writeability, from this dynamic class.
* NOTE - This does NOT cause any
* corresponding property values to be removed from DynaBean instances
* associated with this DynaClass.
*
* @param name
* Name of the dynamic property to remove
*
* @throws IllegalArgumentException
* if name is null
* @throws IllegalStateException
* if this DynaClass is currently
* restricted, so no properties can be removed
*/
@Override
public void remove(final String name){
if (name == null){
throw new IllegalArgumentException("Property name is missing.");
}
if (isRestricted()){
throw new IllegalStateException("DynaClass is currently restricted. No properties can be removed.");
}
// Remove, if property doesn't exist
if (values.containsKey(name)){
values.remove(name);
}
}
// ------------------- Additional Public Methods ----------------------------------
/**
* Should this DynaClass return a null from
* the getDynaProperty(name) method if the property
* doesn't exist.
*
* @return true if a null {@link DynaProperty}
* should be returned if the property doesn't exist, otherwise
* false if a new {@link DynaProperty} should be created.
*/
public boolean isReturnNull(){
return returnNull;
}
/**
* Set whether this DynaClass should return a null from
* the getDynaProperty(name) method if the property
* doesn't exist.
*
* @param returnNull
* true if a null {@link DynaProperty}
* should be returned if the property doesn't exist, otherwise
* false if a new {@link DynaProperty} should be created.
*/
public void setReturnNull(final boolean returnNull){
this.returnNull = returnNull;
}
// ------------------- Protected Methods ----------------------------------
/**
*
* Indicate whether a property actually exists.
*
*
*
* N.B. Using getDynaProperty(name) == null
* doesn't work in this implementation because that method might
* return a DynaProperty if it doesn't exist (depending on the
* returnNull indicator).
*
*
* @param name
* Name of the dynamic property
* @return true if the property exists,
* otherwise false
* @throws IllegalArgumentException
* if no property name is specified
*/
@Override
protected boolean isDynaProperty(final String name){
if (name == null){
throw new IllegalArgumentException("Property name is missing.");
}
return values.containsKey(name);
}
}