pkg://jakarta-commons-beanutils-1.7.0-1jpp_4fc.src.rpm:266839/commons-beanutils-1.7.0-src.tar.gz
info downloads
commons-beanutils-1.7.0-src/ 0040755 0000766 0000766 00000000000 10103255135 016556 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/ 0040755 0000766 0000766 00000000000 10103255107 020402 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/ 0040755 0000766 0000766 00000000000 10103255112 023617 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/ 0040755 0000766 0000766 00000000000 10103255111 024405 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/conf/ 0040755 0000766 0000766 00000000000 10103255110 025331 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/conf/MANIFEST.MF 0100644 0000766 0000766 00000000513 10047757214 027002 0 ustar crazybull crazybull Extension-Name: org.apache.commons.beanutils-bean-collections
Specification-Title: Jakarta Commons Beanutils
Specification-Vendor: Apache Software Foundation
Specification-Version: 1.6
Implementation-Title: org.apache.commons.beanutils-bean-collections
Implementation-Vendor: Apache Software Foundation
Implementation-Version: 1.6
commons-beanutils-1.7.0-src/optional/bean-collections/src/java/ 0040755 0000766 0000766 00000000000 10103255110 025325 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/ 0040755 0000766 0000766 00000000000 10103255110 026114 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/ 0040755 0000766 0000766 00000000000 10103255110 027335 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/ 0040755 0000766 0000766 00000000000 10103255110 031010 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/ 0040755 0000766 0000766 00000000000 10103255111 032777 5 ustar crazybull crazybull ././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanComparator.java commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanCom 0100644 0000766 0000766 00000014501 10057714747 034253 0 ustar crazybull crazybull /*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
import java.io.Serializable;
import java.util.Comparator;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.collections.comparators.ComparableComparator;
/**
* <p>
* This comparator compares two beans by the specified bean property.
* It is also possible to compare beans based on nested, indexed,
* combined, mapped bean properties. Please see the {@link PropertyUtilsBean}
* documentation for all property name possibilities.
*
* </p><p>
* <strong>Note:</strong> The BeanComparator passes the values of the specified
* bean property to a ComparableComparator, if no comparator is
* specified in the constructor. If you are comparing two beans based
* on a property that could contain "null" values, a suitable <code>Comparator</code>
* or <code>ComparatorChain</code> should be supplied in the constructor.
* </p>
*
* @author <a href"mailto:epugh@upstate.com">Eric Pugh</a>
* @author Tim O'Brien
*/
public class BeanComparator implements Comparator, Serializable {
private String property;
private Comparator comparator;
/**
* <p>Constructs a Bean Comparator without a property set.
* </p><p>
* <strong>Note</strong> that this is intended to be used
* only in bean-centric environments.
* </p><p>
* Until {@link #setProperty} is called with a non-null value.
* this comparator will compare the Objects only.
* </p>
*/
public BeanComparator() {
this( null );
}
/**
* <p>Constructs a property-based comparator for beans.
* This compares two beans by the property
* specified in the property parameter. This constructor creates
* a <code>BeanComparator</code> that uses a <code>ComparableComparator</code>
* to compare the property values.
* </p>
*
* <p>Passing "null" to this constructor will cause the BeanComparator
* to compare objects based on natural order, that is
* <code>java.lang.Comparable</code>.
* </p>
*
* @param property String Name of a bean property, which may contain the
* name of a simple, nested, indexed, mapped, or combined
* property. See {@link PropertyUtilsBean} for property query language syntax.
* If the property passed in is null then the actual objects will be compared
*/
public BeanComparator( String property ) {
this( property, ComparableComparator.getInstance() );
}
/**
* Constructs a property-based comparator for beans.
* This constructor creates
* a BeanComparator that uses the supplied Comparator to compare
* the property values.
*
* @param property Name of a bean property, can contain the name
* of a simple, nested, indexed, mapped, or combined
* property. See {@link PropertyUtilsBean} for property query language
* syntax.
* @param comparator BeanComparator will pass the values of the
* specified bean property to this Comparator.
* If your bean property is not a comparable or
* contains null values, a suitable comparator
* may be supplied in this constructor.
*/
public BeanComparator( String property, Comparator comparator ) {
setProperty( property );
this.comparator = comparator;
}
/**
* Sets the method to be called to compare two JavaBeans
*
* @param property String method name to call to compare
* If the property passed in is null then the actual objects will be compared
*/
public void setProperty( String property ) {
this.property = property;
}
/**
* Gets the property attribute of the BeanComparator
*
* @return String method name to call to compare.
* A null value indicates that the actual objects will be compared
*/
public String getProperty() {
return property;
}
/**
* Gets the Comparator being used to compare beans.
*/
public Comparator getComparator() {
return comparator;
}
/**
* Compare two JavaBeans by their shared property.
* If {@link #getProperty} is null then the actual objects will be compared.
*
* @param o1 Object The first bean to get data from to compare against
* @param o2 Object The second bean to get data from to compare
* @return int negative or positive based on order
*/
public int compare( Object o1, Object o2 ) {
if ( property == null ) {
// compare the actual objects
return comparator.compare( o1, o2 );
}
try {
Object value1 = PropertyUtils.getProperty( o1, property );
Object value2 = PropertyUtils.getProperty( o2, property );
return comparator.compare( value1, value2 );
}
catch ( Exception e ) {
throw new ClassCastException( e.toString() );
}
}
/**
* Two <code>BeanComparator</code>'s are equals if and only if
* the wrapped comparators and the property names to be compared
* are equal.
*/
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof BeanComparator)) return false;
final BeanComparator beanComparator = (BeanComparator) o;
if (!comparator.equals(beanComparator.comparator)) return false;
if (property != null)
{
if (!property.equals(beanComparator.property)) return false;
}
else
{
return (beanComparator.property == null);
}
return true;
}
/**
* Hashcode compatible with equals.
*/
public int hashCode() {
int result;
result = comparator.hashCode();
return result;
}
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanMap.java commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanMap 0100644 0000766 0000766 00000066147 10066117566 034263 0 ustar crazybull crazybull /*
* Copyright 2001-2004 The Apache Software Foundation
*
* Licensed 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 org.apache.commons.beanutils;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import org.apache.commons.collections.list.UnmodifiableList;
import org.apache.commons.collections.keyvalue.AbstractMapEntry;
import org.apache.commons.collections.set.UnmodifiableSet;
import org.apache.commons.collections.Transformer;
/**
* An implementation of Map for JavaBeans which uses introspection to
* get and put properties in the bean.
* <p>
* If an exception occurs during attempts to get or set a property then the
* property is considered non existent in the Map
*
* @version $Revision: 1.2.2.2 $ $Date: 2004/06/22 21:07:02 $
*
* @author James Strachan
* @author Stephen Colebourne
*/
public class BeanMap extends AbstractMap implements Cloneable {
private transient Object bean;
private transient HashMap readMethods = new HashMap();
private transient HashMap writeMethods = new HashMap();
private transient HashMap types = new HashMap();
/**
* An empty array. Used to invoke accessors via reflection.
*/
public static final Object[] NULL_ARGUMENTS = {};
/**
* Maps primitive Class types to transformers. The transformer
* transform strings into the appropriate primitive wrapper.
*/
public static HashMap defaultTransformers = new HashMap();
static {
defaultTransformers.put(
Boolean.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Boolean.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Character.TYPE,
new Transformer() {
public Object transform( Object input ) {
return new Character( input.toString().charAt( 0 ) );
}
}
);
defaultTransformers.put(
Byte.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Byte.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Short.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Short.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Integer.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Integer.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Long.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Long.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Float.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Float.valueOf( input.toString() );
}
}
);
defaultTransformers.put(
Double.TYPE,
new Transformer() {
public Object transform( Object input ) {
return Double.valueOf( input.toString() );
}
}
);
}
// Constructors
//-------------------------------------------------------------------------
/**
* Constructs a new empty <code>BeanMap</code>.
*/
public BeanMap() {
}
/**
* Constructs a new <code>BeanMap</code> that operates on the
* specified bean. If the given bean is <code>null</code>, then
* this map will be empty.
*
* @param bean the bean for this map to operate on
*/
public BeanMap(Object bean) {
this.bean = bean;
initialise();
}
// Map interface
//-------------------------------------------------------------------------
/**
* Renders a string representation of this object.
* @return a <code>String</code> representation of this object
*/
public String toString() {
return "BeanMap<" + String.valueOf(bean) + ">";
}
/**
* Clone this bean map using the following process:
*
* <ul>
* <li>If there is no underlying bean, return a cloned BeanMap without a
* bean.
*
* <li>Since there is an underlying bean, try to instantiate a new bean of
* the same type using Class.newInstance().
*
* <li>If the instantiation fails, throw a CloneNotSupportedException
*
* <li>Clone the bean map and set the newly instantiated bean as the
* underlying bean for the bean map.
*
* <li>Copy each property that is both readable and writable from the
* existing object to a cloned bean map.
*
* <li>If anything fails along the way, throw a
* CloneNotSupportedException.
*
* <ul>
*/
public Object clone() throws CloneNotSupportedException {
BeanMap newMap = (BeanMap)super.clone();
if(bean == null) {
// no bean, just an empty bean map at the moment. return a newly
// cloned and empty bean map.
return newMap;
}
Object newBean = null;
Class beanClass = null;
try {
beanClass = bean.getClass();
newBean = beanClass.newInstance();
} catch (Exception e) {
// unable to instantiate
throw new CloneNotSupportedException
("Unable to instantiate the underlying bean \"" +
beanClass.getName() + "\": " + e);
}
try {
newMap.setBean(newBean);
} catch (Exception exception) {
throw new CloneNotSupportedException
("Unable to set bean in the cloned bean map: " +
exception);
}
try {
// copy only properties that are readable and writable. If its
// not readable, we can't get the value from the old map. If
// its not writable, we can't write a value into the new map.
Iterator readableKeys = readMethods.keySet().iterator();
while(readableKeys.hasNext()) {
Object key = readableKeys.next();
if(getWriteMethod(key) != null) {
newMap.put(key, get(key));
}
}
} catch (Exception exception) {
throw new CloneNotSupportedException
("Unable to copy bean values to cloned bean map: " +
exception);
}
return newMap;
}
/**
* Puts all of the writable properties from the given BeanMap into this
* BeanMap. Read-only and Write-only properties will be ignored.
*
* @param map the BeanMap whose properties to put
*/
public void putAllWriteable(BeanMap map) {
Iterator readableKeys = map.readMethods.keySet().iterator();
while (readableKeys.hasNext()) {
Object key = readableKeys.next();
if (getWriteMethod(key) != null) {
this.put(key, map.get(key));
}
}
}
/**
* This method reinitializes the bean map to have default values for the
* bean's properties. This is accomplished by constructing a new instance
* of the bean which the map uses as its underlying data source. This
* behavior for <code>clear()</code> differs from the Map contract in that
* the mappings are not actually removed from the map (the mappings for a
* BeanMap are fixed).
*/
public void clear() {
if(bean == null) return;
Class beanClass = null;
try {
beanClass = bean.getClass();
bean = beanClass.newInstance();
}
catch (Exception e) {
throw new UnsupportedOperationException( "Could not create new instance of class: " + beanClass );
}
}
/**
* Returns true if the bean defines a property with the given name.
* <p>
* The given name must be a <code>String</code>; if not, this method
* returns false. This method will also return false if the bean
* does not define a property with that name.
* <p>
* Write-only properties will not be matched as the test operates against
* property read methods.
*
* @param name the name of the property to check
* @return false if the given name is null or is not a <code>String</code>;
* false if the bean does not define a property with that name; or
* true if the bean does define a property with that name
*/
public boolean containsKey(Object name) {
Method method = getReadMethod(name);
return method != null;
}
/**
* Returns true if the bean defines a property whose current value is
* the given object.
*
* @param value the value to check
* @return false true if the bean has at least one property whose
* current value is that object, false otherwise
*/
public boolean containsValue(Object value) {
// use default implementation
return super.containsValue(value);
}
/**
* Returns the value of the bean's property with the given name.
* <p>
* The given name must be a {@link String} and must not be
* null; otherwise, this method returns <code>null</code>.
* If the bean defines a property with the given name, the value of
* that property is returned. Otherwise, <code>null</code> is
* returned.
* <p>
* Write-only properties will not be matched as the test operates against
* property read methods.
*
* @param name the name of the property whose value to return
* @return the value of the property with that name
*/
public Object get(Object name) {
if ( bean != null ) {
Method method = getReadMethod( name );
if ( method != null ) {
try {
return method.invoke( bean, NULL_ARGUMENTS );
}
catch ( IllegalAccessException e ) {
logWarn( e );
}
catch ( IllegalArgumentException e ) {
logWarn( e );
}
catch ( InvocationTargetException e ) {
logWarn( e );
}
catch ( NullPointerException e ) {
logWarn( e );
}
}
}
return null;
}
/**
* Sets the bean property with the given name to the given value.
*
* @param name the name of the property to set
* @param value the value to set that property to
* @return the previous value of that property
* @throws IllegalArgumentException if the given name is null;
* if the given name is not a {@link String}; if the bean doesn't
* define a property with that name; or if the bean property with
* that name is read-only
*/
public Object put(Object name, Object value) throws IllegalArgumentException, ClassCastException {
if ( bean != null ) {
Object oldValue = get( name );
Method method = getWriteMethod( name );
if ( method == null ) {
throw new IllegalArgumentException( "The bean of type: "+ bean.getClass().getName() + " has no property called: " + name );
}
try {
Object[] arguments = createWriteMethodArguments( method, value );
method.invoke( bean, arguments );
Object newValue = get( name );
firePropertyChange( name, oldValue, newValue );
}
catch ( InvocationTargetException e ) {
logInfo( e );
throw new IllegalArgumentException( e.getMessage() );
}
catch ( IllegalAccessException e ) {
logInfo( e );
throw new IllegalArgumentException( e.getMessage() );
}
return oldValue;
}
return null;
}
/**
* Returns the number of properties defined by the bean.
*
* @return the number of properties defined by the bean
*/
public int size() {
return readMethods.size();
}
/**
* Get the keys for this BeanMap.
* <p>
* Write-only properties are <b>not</b> included in the returned set of
* property names, although it is possible to set their value and to get
* their type.
*
* @return BeanMap keys. The Set returned by this method is not
* modifiable.
*/
public Set keySet() {
return UnmodifiableSet.decorate(readMethods.keySet());
}
/**
* Gets a Set of MapEntry objects that are the mappings for this BeanMap.
* <p>
* Each MapEntry can be set but not removed.
*
* @return the unmodifiable set of mappings
*/
public Set entrySet() {
return UnmodifiableSet.decorate(new AbstractSet() {
public Iterator iterator() {
return entryIterator();
}
public int size() {
return BeanMap.this.readMethods.size();
}
});
}
/**
* Returns the values for the BeanMap.
*
* @return values for the BeanMap. The returned collection is not
* modifiable.
*/
public Collection values() {
ArrayList answer = new ArrayList( readMethods.size() );
for ( Iterator iter = valueIterator(); iter.hasNext(); ) {
answer.add( iter.next() );
}
return UnmodifiableList.decorate(answer);
}
// Helper methods
//-------------------------------------------------------------------------
/**
* Returns the type of the property with the given name.
*
* @param name the name of the property
* @return the type of the property, or <code>null</code> if no such
* property exists
*/
public Class getType(String name) {
return (Class) types.get( name );
}
/**
* Convenience method for getting an iterator over the keys.
* <p>
* Write-only properties will not be returned in the iterator.
*
* @return an iterator over the keys
*/
public Iterator keyIterator() {
return readMethods.keySet().iterator();
}
/**
* Convenience method for getting an iterator over the values.
*
* @return an iterator over the values
*/
public Iterator valueIterator() {
final Iterator iter = keyIterator();
return new Iterator() {
public boolean hasNext() {
return iter.hasNext();
}
public Object next() {
Object key = iter.next();
return get(key);
}
public void remove() {
throw new UnsupportedOperationException( "remove() not supported for BeanMap" );
}
};
}
/**
* Convenience method for getting an iterator over the entries.
*
* @return an iterator over the entries
*/
public Iterator entryIterator() {
final Iterator iter = keyIterator();
return new Iterator() {
public boolean hasNext() {
return iter.hasNext();
}
public Object next() {
Object key = iter.next();
Object value = get(key);
return new Entry( BeanMap.this, key, value );
}
public void remove() {
throw new UnsupportedOperationException( "remove() not supported for BeanMap" );
}
};
}
// Properties
//-------------------------------------------------------------------------
/**
* Returns the bean currently being operated on. The return value may
* be null if this map is empty.
*
* @return the bean being operated on by this map
*/
public Object getBean() {
return bean;
}
/**
* Sets the bean to be operated on by this map. The given value may
* be null, in which case this map will be empty.
*
* @param newBean the new bean to operate on
*/
public void setBean( Object newBean ) {
bean = newBean;
reinitialise();
}
/**
* Returns the accessor for the property with the given name.
*
* @param name the name of the property
* @return the accessor method for the property, or null
*/
public Method getReadMethod(String name) {
return (Method) readMethods.get(name);
}
/**
* Returns the mutator for the property with the given name.
*
* @param name the name of the property
* @return the mutator method for the property, or null
*/
public Method getWriteMethod(String name) {
return (Method) writeMethods.get(name);
}
// Implementation methods
//-------------------------------------------------------------------------
/**
* Returns the accessor for the property with the given name.
*
* @param name the name of the property
* @return null if the name is null; null if the name is not a
* {@link String}; null if no such property exists; or the accessor
* method for that property
*/
protected Method getReadMethod( Object name ) {
return (Method) readMethods.get( name );
}
/**
* Returns the mutator for the property with the given name.
*
* @param name the name of the
* @return null if the name is null; null if the name is not a
* {@link String}; null if no such property exists; null if the
* property is read-only; or the mutator method for that property
*/
protected Method getWriteMethod( Object name ) {
return (Method) writeMethods.get( name );
}
/**
* Reinitializes this bean. Called during {@link #setBean(Object)}.
* Does introspection to find properties.
*/
protected void reinitialise() {
readMethods.clear();
writeMethods.clear();
types.clear();
initialise();
}
private void initialise() {
if(getBean() == null) return;
Class beanClass = getBean().getClass();
try {
//BeanInfo beanInfo = Introspector.getBeanInfo( bean, null );
BeanInfo beanInfo = Introspector.getBeanInfo( beanClass );
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
if ( propertyDescriptors != null ) {
for ( int i = 0; i < propertyDescriptors.length; i++ ) {
PropertyDescriptor propertyDescriptor = propertyDescriptors[i];
if ( propertyDescriptor != null ) {
String name = propertyDescriptor.getName();
Method readMethod = propertyDescriptor.getReadMethod();
Method writeMethod = propertyDescriptor.getWriteMethod();
Class aType = propertyDescriptor.getPropertyType();
if ( readMethod != null ) {
readMethods.put( name, readMethod );
}
if ( writeMethods != null ) {
writeMethods.put( name, writeMethod );
}
types.put( name, aType );
}
}
}
}
catch ( IntrospectionException e ) {
logWarn( e );
}
}
/**
* Called during a successful {@link #put(Object,Object)} operation.
* Default implementation does nothing. Override to be notified of
* property changes in the bean caused by this map.
*
* @param key the name of the property that changed
* @param oldValue the old value for that property
* @param newValue the new value for that property
*/
protected void firePropertyChange( Object key, Object oldValue, Object newValue ) {
}
// Implementation classes
//-------------------------------------------------------------------------
/**
* Map entry used by {@link BeanMap}.
*/
protected static class Entry extends AbstractMapEntry {
private BeanMap owner;
/**
* Constructs a new <code>Entry</code>.
*
* @param owner the BeanMap this entry belongs to
* @param key the key for this entry
* @param value the value for this entry
*/
protected Entry( BeanMap owner, Object key, Object value ) {
super( key, value );
this.owner = owner;
}
/**
* Sets the value.
*
* @param value the new value for the entry
* @return the old value for the entry
*/
public Object setValue(Object value) {
Object key = getKey();
Object oldValue = owner.get( key );
owner.put( key, value );
Object newValue = owner.get( key );
super.setValue( newValue );
return oldValue;
}
}
/**
* Creates an array of parameters to pass to the given mutator method.
* If the given object is not the right type to pass to the method
* directly, it will be converted using {@link #convertType(Class,Object)}.
*
* @param method the mutator method
* @param value the value to pass to the mutator method
* @return an array containing one object that is either the given value
* or a transformed value
* @throws IllegalAccessException if {@link #convertType(Class,Object)}
* raises it
* @throws IllegalArgumentException if any other exception is raised
* by {@link #convertType(Class,Object)}
*/
protected Object[] createWriteMethodArguments( Method method, Object value ) throws IllegalAccessException, ClassCastException {
try {
if ( value != null ) {
Class[] types = method.getParameterTypes();
if ( types != null && types.length > 0 ) {
Class paramType = types[0];
if ( ! paramType.isAssignableFrom( value.getClass() ) ) {
value = convertType( paramType, value );
}
}
}
Object[] answer = { value };
return answer;
}
catch ( InvocationTargetException e ) {
logInfo( e );
throw new IllegalArgumentException( e.getMessage() );
}
catch ( InstantiationException e ) {
logInfo( e );
throw new IllegalArgumentException( e.getMessage() );
}
}
/**
* Converts the given value to the given type. First, reflection is
* is used to find a public constructor declared by the given class
* that takes one argument, which must be the precise type of the
* given value. If such a constructor is found, a new object is
* created by passing the given value to that constructor, and the
* newly constructed object is returned.<P>
*
* If no such constructor exists, and the given type is a primitive
* type, then the given value is converted to a string using its
* {@link Object#toString() toString()} method, and that string is
* parsed into the correct primitive type using, for instance,
* {@link Integer#valueOf(String)} to convert the string into an
* <code>int</code>.<P>
*
* If no special constructor exists and the given type is not a
* primitive type, this method returns the original value.
*
* @param newType the type to convert the value to
* @param value the value to convert
* @return the converted value
* @throws NumberFormatException if newType is a primitive type, and
* the string representation of the given value cannot be converted
* to that type
* @throws InstantiationException if the constructor found with
* reflection raises it
* @throws InvocationTargetException if the constructor found with
* reflection raises it
* @throws IllegalAccessException never
* @throws IllegalArgumentException never
*/
protected Object convertType( Class newType, Object value )
throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
// try call constructor
Class[] types = { value.getClass() };
try {
Constructor constructor = newType.getConstructor( types );
Object[] arguments = { value };
return constructor.newInstance( arguments );
}
catch ( NoSuchMethodException e ) {
// try using the transformers
Transformer transformer = getTypeTransformer( newType );
if ( transformer != null ) {
return transformer.transform( value );
}
return value;
}
}
/**
* Returns a transformer for the given primitive type.
*
* @param aType the primitive type whose transformer to return
* @return a transformer that will convert strings into that type,
* or null if the given type is not a primitive type
*/
protected Transformer getTypeTransformer( Class aType ) {
return (Transformer) defaultTransformers.get( aType );
}
/**
* Logs the given exception to <code>System.out</code>. Used to display
* warnings while accessing/mutating the bean.
*
* @param ex the exception to log
*/
protected void logInfo(Exception ex) {
// Deliberately do not use LOG4J or Commons Logging to avoid dependencies
System.out.println( "INFO: Exception: " + ex );
}
/**
* Logs the given exception to <code>System.err</code>. Used to display
* errors while accessing/mutating the bean.
*
* @param ex the exception to log
*/
protected void logWarn(Exception ex) {
// Deliberately do not use LOG4J or Commons Logging to avoid dependencies
System.out.println( "WARN: Exception: " + ex );
ex.printStackTrace();
}
}
././@LongLink 0000000 0000000 0000000 00000000157 00000000000 011570 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanPredicate.java commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanPre 0100644 0000766 0000766 00000010154 10055210322 034235 0 ustar crazybull crazybull /*
* Copyright 2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
import org.apache.commons.collections.Predicate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.lang.reflect.InvocationTargetException;
/**
* <p>Predicate implementation that applies the given <code>Predicate</code>
* to the result of calling the given property getter.
* </p>
*/
public class BeanPredicate implements Predicate {
private final Log log = LogFactory.getLog(this.getClass());
/** Name of the property whose value will be predicated */
private String propertyName;
/** <code>Predicate</code> to be applied to the property value */
private Predicate predicate;
/**
* Constructs a <code>BeanPredicate</code> that applies the given
* <code>Predicate</code> to the named property value.
* @param propertyName the name of the property whose value is to be predicated,
* not null
* @param predicate the <code>Predicate</code> to be applied,
* not null
*/
public BeanPredicate(String propertyName, Predicate predicate) {
this.propertyName = propertyName;
this.predicate = predicate;
}
/**
* Evaluates the given object by applying the {@link #getPredicate()}
* to a property value named by {@link #getPropertyName()}.
* @throws IllegalAccessException when the property cannot be evaluated
*/
public boolean evaluate(Object object) {
boolean evaluation = false;
try {
Object propValue = PropertyUtils.getProperty( object, propertyName );
evaluation = predicate.evaluate(propValue);
} catch (IllegalArgumentException e) {
final String errorMsg = "Problem during evaluation.";
log.error("ERROR: " + errorMsg, e);
throw e;
} catch (IllegalAccessException e) {
final String errorMsg = "Unable to access the property provided.";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
} catch (InvocationTargetException e) {
final String errorMsg = "Exception occurred in property's getter";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
} catch (NoSuchMethodException e) {
final String errorMsg = "Property not found.";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
}
return evaluation;
}
/**
* Gets the name of the property whose value is to be predicated.
* in the evaluation.
* @return the property name, not null
*/
public String getPropertyName() {
return propertyName;
}
/**
* Sets the name of the property whose value is to be predicated.
* @param propertyName the name of the property whose value is to be predicated,
* not null
*/
public void setPropertyName(String propertyName) {
this.propertyName = propertyName;
}
/**
* Gets the <code>Predicate</code> to be applied to the value of the named property
* during {@link #evaluate}.
* @return <code>Predicate</code>, not null
*/
public Predicate getPredicate() {
return predicate;
}
/**
* Sets the <code>Predicate</code> to be applied to the value of the named property
* during {@link evaluate}.
* @param predicate <code>Predicate</code>, not null
*/
public void setPredicate(Predicate predicate) {
this.predicate = predicate;
}
}
././@LongLink 0000000 0000000 0000000 00000000200 00000000000 011555 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanPropertyValueChangeClosure.java commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanPro 0100644 0000766 0000766 00000023642 10047757422 034277 0 ustar crazybull crazybull /*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
import org.apache.commons.collections.Closure;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.lang.reflect.InvocationTargetException;
/**
* <p><code>Closure</code> that sets a property.</p>
* <p>
* An implementation of <code>org.apache.commons.collections.Closure</code> that updates
* a specified property on the object provided with a specified value.
* The <code>BeanPropertyValueChangeClosure</code> constructor takes two parameters which determine
* what property will be updated and with what value.
* <dl>
* <dt>
* <b><code><pre>public BeanPropertyValueChangeClosure( String propertyName, Object propertyValue )</pre></code></b>
* </dt>
* <dd>
* Will create a <code>Closure</code> that will update an object by setting the property
* specified by <code>propertyName</code> to the value specified by <code>propertyValue</code>.
* </dd>
* </dl>
*
* <p/>
* <strong>Note:</strong> Property names can be a simple, nested, indexed, or mapped property as defined by
* <code>org.apache.commons.beanutils.PropertyUtils</code>. If any object in the property path
* specified by <code>propertyName</code> is <code>null</code> then the outcome is based on the
* value of the <code>ignoreNull</code> attribute.
*
* <p/>
* A typical usage might look like:
* <code><pre>
* // create the closure
* BeanPropertyValueChangeClosure closure =
* new BeanPropertyValueChangeClosure( "activeEmployee", Boolean.TRUE );
*
* // update the Collection
* CollectionUtils.forAllDo( peopleCollection, closure );
* </pre></code>
* <p/>
*
* This would take a <code>Collection</code> of person objects and update the
* <code>activeEmployee</code> property of each object in the <code>Collection</code> to
* <code>true</code>. Assuming...
* <ul>
* <li>
* The top level object in the <code>peopleCollection</code> is an object which represents a
* person.
* </li>
* <li>
* The person object has a <code>setActiveEmployee( boolean )</code> method which updates
* the value for the object's <code>activeEmployee</code> property.
* </li>
* </ul>
*
* @author Norm Deane
* @see org.apache.commons.beanutils.PropertyUtils
* @see org.apache.commons.collections.Closure
*/
public class BeanPropertyValueChangeClosure implements Closure {
/** For logging. */
private final Log log = LogFactory.getLog(this.getClass());
/**
* The name of the property which will be updated when this <code>Closure</code> executes.
*/
private String propertyName;
/**
* The value that the property specified by <code>propertyName</code>
* will be updated to when this <code>Closure</code> executes.
*/
private Object propertyValue;
/**
* Determines whether <code>null</code> objects in the property path will genenerate an
* <code>IllegalArgumentException</code> or not. If set to <code>true</code> then if any objects
* in the property path leading up to the target property evaluate to <code>null</code> then the
* <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged but
* not rethrown. If set to <code>false</code> then if any objects in the property path leading
* up to the target property evaluate to <code>null</code> then the
* <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged and
* rethrown.
*/
private boolean ignoreNull;
/**
* Constructor which takes the name of the property to be changed, the new value to set
* the property to, and assumes <code>ignoreNull</code> to be <code>false</code>.
*
* @param propertyName The name of the property that will be updated with the value specified by
* <code>propertyValue</code>.
* @param propertyValue The value that <code>propertyName</code> will be set to on the target
* object.
* @throws IllegalArgumentException If the propertyName provided is null or empty.
*/
public BeanPropertyValueChangeClosure(String propertyName, Object propertyValue) {
this(propertyName, propertyValue, false);
}
/**
* Constructor which takes the name of the property to be changed, the new value to set
* the property to and a boolean which determines whether <code>null</code> objects in the
* property path will genenerate an <code>IllegalArgumentException</code> or not.
*
* @param propertyName The name of the property that will be updated with the value specified by
* <code>propertyValue</code>.
* @param propertyValue The value that <code>propertyName</code> will be set to on the target
* object.
* @param ignoreNull Determines whether <code>null</code> objects in the property path will
* genenerate an <code>IllegalArgumentException</code> or not.
* @throws IllegalArgumentException If the propertyName provided is null or empty.
*/
public BeanPropertyValueChangeClosure(String propertyName, Object propertyValue, boolean ignoreNull) {
super();
if ((propertyName != null) && (propertyName.length() > 0)) {
this.propertyName = propertyName;
this.propertyValue = propertyValue;
this.ignoreNull = ignoreNull;
} else {
throw new IllegalArgumentException("propertyName cannot be null or empty");
}
}
/**
* Updates the target object provided using the property update criteria provided when this
* <code>BeanPropertyValueChangeClosure</code> was constructed. If any object in the property
* path leading up to the target property is <code>null</code> then the outcome will be based on
* the value of the <code>ignoreNull</code> attribute. By default, <code>ignoreNull</code> is
* <code>false</code> and would result in an <code>IllegalArgumentException</code> if an object
* in the property path leading up to the target property is <code>null</code>.
*
* @param object The object to be updated.
* @throws IllegalArgumentException If an IllegalAccessException, InvocationTargetException, or
* NoSuchMethodException is thrown when trying to access the property specified on the object
* provided. Or if an object in the property path provided is <code>null</code> and
* <code>ignoreNull</code> is set to <code>false</code>.
*/
public void execute(Object object) {
try {
PropertyUtils.setProperty(object, propertyName, propertyValue);
} catch (IllegalArgumentException e) {
final String errorMsg = "Unable to execute Closure. Null value encountered in property path...";
if (ignoreNull) {
log.warn("WARNING: " + errorMsg, e);
} else {
log.error("ERROR: " + errorMsg, e);
throw e;
}
} catch (IllegalAccessException e) {
final String errorMsg = "Unable to access the property provided.";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
} catch (InvocationTargetException e) {
final String errorMsg = "Exception occurred in property's getter";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
} catch (NoSuchMethodException e) {
final String errorMsg = "Property not found";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
}
}
/**
* Returns the name of the property which will be updated when this <code>Closure</code> executes.
*
* @return The name of the property which will be updated when this <code>Closure</code> executes.
*/
public String getPropertyName() {
return propertyName;
}
/**
* Returns the value that the property specified by <code>propertyName</code>
* will be updated to when this <code>Closure</code> executes.
*
* @return The value that the property specified by <code>propertyName</code>
* will be updated to when this <code>Closure</code> executes.
*/
public Object getPropertyValue() {
return propertyValue;
}
/**
* Returns the flag that determines whether <code>null</code> objects in the property path will
* genenerate an <code>IllegalArgumentException</code> or not. If set to <code>true</code> then
* if any objects in the property path leading up to the target property evaluate to
* <code>null</code> then the <code>IllegalArgumentException</code> throw by
* <code>PropertyUtils</code> will be logged but not rethrown. If set to <code>false</code> then
* if any objects in the property path leading up to the target property evaluate to
* <code>null</code> then the <code>IllegalArgumentException</code> throw by
* <code>PropertyUtils</code> will be logged and rethrown.
*
* @return The flag that determines whether <code>null</code> objects in the property path will
* genenerate an <code>IllegalArgumentException</code> or not.
*/
public boolean isIgnoreNull() {
return ignoreNull;
}
}
././@LongLink 0000000 0000000 0000000 00000000202 00000000000 011557 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanPropertyValueEqualsPredicate.java commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanPro 0100644 0000766 0000766 00000027435 10047757377 034314 0 ustar crazybull crazybull /*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
import org.apache.commons.collections.Predicate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.lang.reflect.InvocationTargetException;
/**
* <p><code>Predicate</code> that evaluates a property value against a specified value.</p>
* <p>
* An implementation of <code>org.apache.commons.collections.Predicate</code> that evaluates a
* property value on the object provided against a specified value and returns <code>true</code>
* if equal; <code>false</code> otherwise.
* The <code>BeanPropertyValueEqualsPredicate</code> constructor takes two parameters which
* determine what property will be evaluated on the target object and what its expected value should
* be.
* <dl>
* <dt>
* <strong><code><pre>public BeanPropertyValueEqualsPredicate( String propertyName, Object propertyValue )</pre></code></strong>
* </dt>
* <dd>
* Will create a <code>Predicate</code> that will evaluate the target object and return
* <code>true</code> if the property specified by <code>propertyName</code> has a value which
* is equal to the the value specified by <code>propertyValue</code>. Or return
* <code>false</code> otherwise.
* </dd>
* </dl>
* </p>
* <p>
* <strong>Note:</strong> Property names can be a simple, nested, indexed, or mapped property as defined by
* <code>org.apache.commons.beanutils.PropertyUtils</code>. If any object in the property path
* specified by <code>propertyName</code> is <code>null</code> then the outcome is based on the
* value of the <code>ignoreNull</code> attribute.
* </p>
* <p>
* A typical usage might look like:
* <code><pre>
* // create the closure
* BeanPropertyValueEqualsPredicate predicate =
* new BeanPropertyValueEqualsPredicate( "activeEmployee", Boolean.FALSE );
*
* // filter the Collection
* CollectionUtils.filter( peopleCollection, predicate );
* </pre></code>
* </p>
* <p>
* This would take a <code>Collection</code> of person objects and filter out any people whose
* <code>activeEmployee</code> property is <code>false</code>. Assuming...
* <ul>
* <li>
* The top level object in the <code>peeopleCollection</code> is an object which represents a
* person.
* </li>
* <li>
* The person object has a <code>getActiveEmployee()</code> method which returns
* the boolean value for the object's <code>activeEmployee</code> property.
* </li>
* </ul>
* </p>
* <p>
* Another typical usage might look like:
* <code><pre>
* // create the closure
* BeanPropertyValueEqualsPredicate predicate =
* new BeanPropertyValueEqualsPredicate( "personId", "456-12-1234" );
*
* // search the Collection
* CollectionUtils.find( peopleCollection, predicate );
* </pre><code>
* </p>
* <p>
* This would search a <code>Collection</code> of person objects and return the first object whose
* <code>personId</code> property value equals <code>456-12-1234</code>. Assuming...
* <ul>
* <li>
* The top level object in the <code>peeopleCollection</code> is an object which represents a
* person.
* </li>
* <li>
* The person object has a <code>getPersonId()</code> method which returns
* the value for the object's <code>personId</code> property.
* </li>
* </ul>
* </p>
*
* @author Norm Deane
* @see org.apache.commons.beanutils.PropertyUtils
* @see org.apache.commons.collections.Predicate
*/
public class BeanPropertyValueEqualsPredicate implements Predicate {
/** For logging. */
private final Log log = LogFactory.getLog(this.getClass());
/**
* The name of the property which will be evaluated when this <code>Predicate</code> is executed.
*/
private String propertyName;
/**
* The value that the property specified by <code>propertyName</code>
* will be compared to when this <code>Predicate</code> executes.
*/
private Object propertyValue;
/**
* <p>Should <code>null</code> objects in the property path be ignored?</p>
* <p>
* Determines whether <code>null</code> objects in the property path will genenerate an
* <code>IllegalArgumentException</code> or not. If set to <code>true</code> then if any objects
* in the property path evaluate to <code>null</code> then the
* <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged but
* not rethrown and <code>false</code> will be returned. If set to <code>false</code> then if
* any objects in the property path evaluate to <code>null</code> then the
* <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged and
* rethrown.
* </p>
*/
private boolean ignoreNull;
/**
* Constructor which takes the name of the property, its expected value to be used in evaluation,
* and assumes <code>ignoreNull</code> to be <code>false</code>.
*
* @param propertyName The name of the property that will be evaluated against the expected value.
* @param propertyValue The value to use in object evaluation.
* @throws IllegalArgumentException If the property name provided is null or empty.
*/
public BeanPropertyValueEqualsPredicate(String propertyName, Object propertyValue) {
this(propertyName, propertyValue, false);
}
/**
* Constructor which takes the name of the property, its expected value
* to be used in evaluation, and a boolean which determines whether <code>null</code> objects in
* the property path will genenerate an <code>IllegalArgumentException</code> or not.
*
* @param propertyName The name of the property that will be evaluated against the expected value.
* @param propertyValue The value to use in object evaluation.
* @param ignoreNull Determines whether <code>null</code> objects in the property path will
* genenerate an <code>IllegalArgumentException</code> or not.
* @throws IllegalArgumentException If the property name provided is null or empty.
*/
public BeanPropertyValueEqualsPredicate(String propertyName, Object propertyValue, boolean ignoreNull) {
super();
if ((propertyName != null) && (propertyName.length() > 0)) {
this.propertyName = propertyName;
this.propertyValue = propertyValue;
this.ignoreNull = ignoreNull;
} else {
throw new IllegalArgumentException("propertyName cannot be null or empty");
}
}
/**
* Evaulates the object provided against the criteria specified when this
* <code>BeanPropertyValueEqualsPredicate</code> was constructed. Equality is based on
* either reference or logical equality as defined by the property object's equals method. If
* any object in the property path leading up to the target property is <code>null</code> then
* the outcome will be based on the value of the <code>ignoreNull</code> attribute. By default,
* <code>ignoreNull</code> is <code>false</code> and would result in an
* <code>IllegalArgumentException</code> if an object in the property path leading up to the
* target property is <code>null</code>.
*
* @param object The object to be evaluated.
* @return True if the object provided meets all the criteria for this <code>Predicate</code>;
* false otherwise.
* @throws IllegalArgumentException If an IllegalAccessException, InvocationTargetException, or
* NoSuchMethodException is thrown when trying to access the property specified on the object
* provided. Or if an object in the property path provided is <code>null</code> and
* <code>ignoreNull</code> is set to <code>false</code>.
*/
public boolean evaluate(Object object) {
boolean evaluation = false;
try {
evaluation = evaluateValue(propertyValue,
PropertyUtils.getProperty(object, propertyName));
} catch (IllegalArgumentException e) {
final String errorMsg = "Problem during evaluation. Null value encountered in property path...";
if (ignoreNull) {
log.warn("WARNING: " + errorMsg, e);
} else {
log.error("ERROR: " + errorMsg, e);
throw e;
}
} catch (IllegalAccessException e) {
final String errorMsg = "Unable to access the property provided.";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
} catch (InvocationTargetException e) {
final String errorMsg = "Exception occurred in property's getter";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
} catch (NoSuchMethodException e) {
final String errorMsg = "Property not found.";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
}
return evaluation;
}
/**
* Utility method which evaluates whether the actual property value equals the expected property
* value.
*
* @param expected The expected value.
* @param actual The actual value.
* @return True if they are equal; false otherwise.
*/
private boolean evaluateValue(Object expected, Object actual) {
return (expected == actual) || ((expected != null) && expected.equals(actual));
}
/**
* Returns the name of the property which will be evaluated when this <code>Predicate</code> is
* executed.
*
* @return The name of the property which will be evaluated when this <code>Predicate</code> is
* executed.
*/
public String getPropertyName() {
return propertyName;
}
/**
* Returns the value that the property specified by <code>propertyName</code> will be compared to
* when this <code>Predicate</code> executes.
*
* @return The value that the property specified by <code>propertyName</code> will be compared to
* when this <code>Predicate</code> executes.
*/
public Object getPropertyValue() {
return propertyValue;
}
/**
* Returns the flag which determines whether <code>null</code> objects in the property path will
* genenerate an <code>IllegalArgumentException</code> or not. If set to <code>true</code> then
* if any objects in the property path evaluate to <code>null</code> then the
* <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged but
* not rethrown and <code>false</code> will be returned. If set to <code>false</code> then if
* any objects in the property path evaluate to <code>null</code> then the
* <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged and
* rethrown.
*
* @return The flag which determines whether <code>null</code> objects in the property path will
* genenerate an <code>IllegalArgumentException</code> or not.
*/
public boolean isIgnoreNull() {
return ignoreNull;
}
}
././@LongLink 0000000 0000000 0000000 00000000200 00000000000 011555 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanToPropertyValueTransformer.java commons-beanutils-1.7.0-src/optional/bean-collections/src/java/org/apache/commons/beanutils/BeanToP 0100644 0000766 0000766 00000022061 10047757350 034233 0 ustar crazybull crazybull /*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
import org.apache.commons.collections.Transformer;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.lang.reflect.InvocationTargetException;
/**
* <p><code>Transformer</code> that outputs a property value.</p>
*
* <p>An implementation of <code>org.apache.commons.collections.Transformer</code> that transforms
* the object provided by returning the value of a specified property of the object. The
* constructor for <code>BeanToPropertyValueTransformer</code> requires the name of the property
* that will be used in the transformation. The property can be a simple, nested, indexed, or
* mapped property as defined by <code>org.apache.commons.beanutils.PropertyUtils</code>. If any
* object in the property path specified by <code>propertyName</code> is <code>null</code> then the
* outcome is based on the value of the <code>ignoreNull</code> attribute.
* </p>
*
* <p>
* A typical usage might look like:
* <code><pre>
* // create the transformer
* BeanToPropertyValueTransformer transformer = new BeanToPropertyValueTransformer( "person.address.city" );
*
* // transform the Collection
* Collection peoplesCities = CollectionUtils.collect( peopleCollection, transformer );
* </pre></code>
* </p>
*
* <p>
* This would take a <code>Collection</code> of person objects and return a <code>Collection</code>
* of objects which represents the cities in which each person lived. Assuming...
* <ul>
* <li>
* The top level object in the <code>peeopleCollection</code> is an object which represents a
* person.
* </li>
* <li>
* The person object has a <code>getAddress()</code> method which returns an object which
* represents a person's address.
* </li>
* <li>
* The address object has a <code>getCity()</code> method which returns an object which
* represents the city in which a person lives.
* </li>
* </ul>
*
* @author Norm Deane
* @see org.apache.commons.beanutils.PropertyUtils
* @see org.apache.commons.collections.Transformer
*/
public class BeanToPropertyValueTransformer implements Transformer {
/** For logging. */
private final Log log = LogFactory.getLog(this.getClass());
/** The name of the property that will be used in the transformation of the object. */
private String propertyName;
/**
* <p>Should null objects on the property path throw an <code>IllegalArgumentException</code>?</p>
* <p>
* Determines whether <code>null</code> objects in the property path will genenerate an
* <code>IllegalArgumentException</code> or not. If set to <code>true</code> then if any objects
* in the property path evaluate to <code>null</code> then the
* <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged but
* not rethrown and <code>null</code> will be returned. If set to <code>false</code> then if any
* objects in the property path evaluate to <code>null</code> then the
* <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged and
* rethrown.
* </p>
*/
private boolean ignoreNull;
/**
* Constructs a Transformer which does not ignore nulls.
* Constructor which takes the name of the property that will be used in the transformation and
* assumes <code>ignoreNull</code> to be <code>false</code>.
*
* @param propertyName The name of the property that will be used in the transformation.
* @throws IllegalArgumentException If the <code>propertyName</code> is <code>null</code> or
* empty.
*/
public BeanToPropertyValueTransformer(String propertyName) {
this(propertyName, false);
}
/**
* Constructs a Transformer and sets ignoreNull.
* Constructor which takes the name of the property that will be used in the transformation and
* a boolean which determines whether <code>null</code> objects in the property path will
* genenerate an <code>IllegalArgumentException</code> or not.
*
* @param propertyName The name of the property that will be used in the transformation.
* @param ignoreNull Determines whether <code>null</code> objects in the property path will
* genenerate an <code>IllegalArgumentException</code> or not.
* @throws IllegalArgumentException If the <code>propertyName</code> is <code>null</code> or
* empty.
*/
public BeanToPropertyValueTransformer(String propertyName, boolean ignoreNull) {
super();
if ((propertyName != null) && (propertyName.length() > 0)) {
this.propertyName = propertyName;
this.ignoreNull = ignoreNull;
} else {
throw new IllegalArgumentException(
"propertyName cannot be null or empty");
}
}
/**
* Returns the value of the property named in the transformer's constructor for
* the object provided. If any object in the property path leading up to the target property is
* <code>null</code> then the outcome will be based on the value of the <code>ignoreNull</code>
* attribute. By default, <code>ignoreNull</code> is <code>false</code> and would result in an
* <code>IllegalArgumentException</code> if an object in the property path leading up to the
* target property is <code>null</code>.
*
* @param object The object to be transformed.
* @return The value of the property named in the transformer's constructor for the object
* provided.
* @throws IllegalArgumentException If an IllegalAccessException, InvocationTargetException, or
* NoSuchMethodException is thrown when trying to access the property specified on the object
* provided. Or if an object in the property path provided is <code>null</code> and
* <code>ignoreNull</code> is set to <code>false</code>.
*/
public Object transform(Object object) {
Object propertyValue = null;
try {
propertyValue = PropertyUtils.getProperty(object, propertyName);
} catch (IllegalArgumentException e) {
final String errorMsg = "Problem during transformation. Null value encountered in property path...";
if (ignoreNull) {
log.warn("WARNING: " + errorMsg, e);
} else {
log.error("ERROR: " + errorMsg, e);
throw e;
}
} catch (IllegalAccessException e) {
final String errorMsg = "Unable to access the property provided.";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
} catch (InvocationTargetException e) {
final String errorMsg = "Exception occurred in property's getter";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
} catch (NoSuchMethodException e) {
final String errorMsg = "No property found for name [" +
propertyName + "]";
log.error(errorMsg, e);
throw new IllegalArgumentException(errorMsg);
}
return propertyValue;
}
/**
* Returns the name of the property that will be used in the transformation of the bean.
*
* @return The name of the property that will be used in the transformation of the bean.
*/
public String getPropertyName() {
return propertyName;
}
/**
* Returns the flag which determines whether <code>null</code> objects in the property path will
* genenerate an <code>IllegalArgumentException</code> or not. If set to <code>true</code> then
* if any objects in the property path evaluate to <code>null</code> then the
* <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged but
* not rethrown and <code>null</code> will be returned. If set to <code>false</code> then if any
* objects in the property path evaluate to <code>null</code> then the
* <code>IllegalArgumentException</code> throw by <code>PropertyUtils</code> will be logged and
* rethrown.
*
* @return The flag which determines whether <code>null</code> objects in the property path will
* genenerate an <code>IllegalArgumentException</code> or not.
*/
public boolean isIgnoreNull() {
return ignoreNull;
}
}
commons-beanutils-1.7.0-src/optional/bean-collections/src/java/overview.html 0100644 0000766 0000766 00000001365 10101547630 030074 0 ustar crazybull crazybull <html>
<head>
<title>Overview Documentation for COMMONS-BEANUTILS BEAN COLLECTIONS</title>
</head>
<body bgcolor="white">
<p>The <em>Bean Introspection Utilities</em> component of the Jakarta Commons
subproject offers low-level utility classes that assist in getting and setting
property values on Java classes that follow the naming design patterns outlined
in the JavaBeans Specification, as well as mechanisms for dynamically defining
and accessing bean properties.</p>
<p>
The Bean-Collections optional distribution contains objects which apply these
techniques to collections. They rely on commons-collections 3.0 (or higher).
</p>
<p>The documentation for this optional package is included with the core Beanutils
documentation.</p>
</body>
</html>
commons-beanutils-1.7.0-src/optional/bean-collections/src/test/ 0040755 0000766 0000766 00000000000 10103255111 025364 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/ 0040755 0000766 0000766 00000000000 10103255111 026153 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/ 0040755 0000766 0000766 00000000000 10103255111 027374 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/ 0040755 0000766 0000766 00000000000 10103255111 031047 5 ustar crazybull crazybull commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/ 0040755 0000766 0000766 00000000000 10103255112 033036 5 ustar crazybull crazybull ././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/AbstractParent.java commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/Abstrac 0100644 0000766 0000766 00000002577 10047757570 034376 0 ustar crazybull crazybull /*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
public abstract class AbstractParent {
private Child child;
public Child getChild()
{
return child;
}
/**
* Method which matches signature but which has wrong parameters
*/
public String testAddChild(String badParameter) {
return null;
}
/**
* Method which matches signature but which has wrong parameters
*/
public String testAddChild2(String ignore, String badParameter) {
return null;
}
public String testAddChild(Child child) {
this.child = child;
return child.getName();
}
public String testAddChild2(String ignore, Child child) {
this.child = child;
return child.getName();
}
}
././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/AlphaBean.java commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/AlphaBe 0100644 0000766 0000766 00000002152 10047757634 034301 0 ustar crazybull crazybull /*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
public class AlphaBean extends AbstractParent implements Child {
private String name;
public AlphaBean() {}
public AlphaBean(String name) {
setName(name);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* Used for testing that correct exception is thrown.
*/
public void bogus(String badParameter){}
}
././@LongLink 0000000 0000000 0000000 00000000172 00000000000 011565 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/BeanCollectionsTestSuite.java commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/BeanCol 0100644 0000766 0000766 00000003332 10050253623 034270 0 ustar crazybull crazybull /*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import junit.framework.TestCase;
import junit.framework.Test;
import junit.framework.TestSuite;
/**
* <p>Test suite which runs all the test cases application to beans in collections.
*
* @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
* @version $Revision: 1.2 $
*/
public class BeanCollectionsTestSuite extends TestCase {
public BeanCollectionsTestSuite(java.lang.String testName) {
super(testName);
}
public static void main(java.lang.String[] args) {
junit.textui.TestRunner.run(suite());
}
public static junit.framework.Test suite() {
TestSuite suite = new TestSuite();
suite.addTestSuite(BeanComparatorTestCase.class);
suite.addTestSuite(BeanToPropertyValueTransformerTest.class);
suite.addTestSuite(BeanPropertyValueEqualsPredicateTest.class);
suite.addTestSuite(BeanPropertyValueChangeClosureTest.class);
suite.addTestSuite(TestBeanMap.class);
return suite;
}
}
././@LongLink 0000000 0000000 0000000 00000000170 00000000000 011563 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/BeanComparatorTestCase.java commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/BeanCom 0100644 0000766 0000766 00000016176 10047757703 034321 0 ustar crazybull crazybull /*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import junit.framework.TestCase;
import junit.framework.Test;
import junit.framework.TestSuite;
/**
* <p>
* Test Case for the BeanComparator class.
*
* @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
* @version $Revision: 1.1 $
*/
public class BeanComparatorTestCase extends TestCase {
// ---------------------------------------------------- Instance Variables
/**
* The test beans for each test.
*/
protected TestBean bean = null;
protected AlphaBean alphaBean1 = null;
protected AlphaBean alphaBean2 = null;
// The test BeanComparator
protected BeanComparator beanComparator = null;
// ---------------------------------------------------------- Constructors
/**
* Construct a new instance of this test case.
*
* @param name Name of the test case
*/
public BeanComparatorTestCase(String name) {
super(name);
}
// -------------------------------------------------- Overall Test Methods
/**
* Set up instance variables required by this test case.
*/
public void setUp() {
bean = new TestBean();
alphaBean1 = new AlphaBean("alphaBean1");
alphaBean2 = new AlphaBean("alphaBean2");
}
/**
* Return the tests included in this test suite.
*/
public static Test suite() {
return (new TestSuite(BeanComparatorTestCase.class));
}
/**
* Tear down instance variables required by this test case.
*/
public void tearDown() {
bean = null;
alphaBean1 = null;
alphaBean2 = null;
beanComparator = null;
}
// ------------------------------------------------ Individual Test Methods
/**
* tests comparing two beans via their name using the default Comparator
*/
public void testSimpleCompare() {
try {
beanComparator = new BeanComparator("name");
int result = beanComparator.compare(alphaBean1, alphaBean2);
assertTrue("Comparator did not sort properly. Result:" + result,result==-1);
}
catch (Exception e) {
fail("Exception");
}
}
/**
* tests comparing two beans via their name using the default Comparator, but the inverse
*/
public void testSimpleCompareInverse() {
try {
beanComparator = new BeanComparator("name");
int result = beanComparator.compare(alphaBean2, alphaBean1);
assertTrue("Comparator did not sort properly. Result:" + result,result==1);
}
catch (Exception e) {
fail("Exception" + e);
}
}
/**
* tests comparing two beans via their name using the default Comparator where they have the same value.
*/
public void testCompareIdentical() {
try {
alphaBean1 = new AlphaBean("alphabean");
alphaBean2 = new AlphaBean("alphabean");
beanComparator = new BeanComparator("name");
int result = beanComparator.compare(alphaBean1, alphaBean2);
assertTrue("Comparator did not sort properly. Result:" + result,result==0);
}
catch (Exception e) {
fail("Exception");
}
}
/**
* tests comparing one bean against itself.
*/
public void testCompareBeanAgainstSelf() {
try {
beanComparator = new BeanComparator("name");
int result = beanComparator.compare(alphaBean1, alphaBean1);
assertTrue("Comparator did not sort properly. Result:" + result,result==0);
}
catch (Exception e) {
fail("Exception");
}
}
/**
* tests comparing two beans via their name using the default Comparator, but with one of the beans
* being null.
*/
public void testCompareWithNulls() {
try {
beanComparator = new BeanComparator("name");
beanComparator.compare(alphaBean2, null);
// DEP not sure if this is the best way to test an exception?
fail("Should not be able to compare a null value.");
}
catch (Exception e) {
}
}
/**
* tests comparing two beans who don't have a property
*/
public void testCompareOnMissingProperty() {
try {
beanComparator = new BeanComparator("bogusName");
beanComparator.compare(alphaBean2, alphaBean1);
fail("should not be able to compare");
}
catch (ClassCastException cce){
assertTrue("Wrong exception was thrown.",cce.toString().indexOf("Unknown property") > -1);
}
catch (Exception e) {
fail("Exception" + e);
}
}
/**
* tests comparing two beans on a boolean property, which is not possible.
*/
public void testCompareOnBooleanProperty() {
try {
TestBean testBeanA = new TestBean();
TestBean testBeanB = new TestBean();
testBeanA.setBooleanProperty(true);
testBeanB.setBooleanProperty(false);
beanComparator = new BeanComparator("booleanProperty");
beanComparator.compare(testBeanA, testBeanB);
fail("BeanComparator should throw an exception when comparing two booleans.");
}
catch (ClassCastException cce){
; // Expected result
}
catch (Exception e) {
fail("Exception" + e);
}
}
/**
* tests comparing two beans on a boolean property, then changing the property and testing
*/
public void testSetProperty() {
try {
TestBean testBeanA = new TestBean();
TestBean testBeanB = new TestBean();
testBeanA.setDoubleProperty(5.5);
testBeanB.setDoubleProperty(1.0);
beanComparator = new BeanComparator("doubleProperty");
int result = beanComparator.compare(testBeanA, testBeanB);
assertTrue("Comparator did not sort properly. Result:" + result,result==1);
testBeanA.setStringProperty("string 1");
testBeanB.setStringProperty("string 2");
beanComparator.setProperty("stringProperty");
result = beanComparator.compare(testBeanA, testBeanB);
assertTrue("Comparator did not sort properly. Result:" + result,result==-1);
}
catch (ClassCastException cce){
fail("ClassCaseException " + cce.toString());
}
catch (Exception e) {
fail("Exception" + e);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000167 00000000000 011571 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/BeanPredicateTestCase.java commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/BeanPre 0100644 0000766 0000766 00000004302 10047757756 034325 0 ustar crazybull crazybull /*
* Copyright 2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
import junit.framework.TestCase;
import org.apache.commons.collections.functors.EqualPredicate;
import org.apache.commons.collections.functors.InstanceofPredicate;
import org.apache.commons.collections.functors.NotPredicate;
import org.apache.commons.collections.functors.NullPredicate;
public class BeanPredicateTestCase extends TestCase {
public BeanPredicateTestCase(String name) {
super(name);
}
public void testEqual() {
BeanPredicate predicate =
new BeanPredicate("stringProperty",new EqualPredicate("foo"));
assertTrue(predicate.evaluate(new TestBean("foo")));
assertTrue(!predicate.evaluate(new TestBean("bar")));
}
public void testNotEqual() {
BeanPredicate predicate =
new BeanPredicate("stringProperty",new NotPredicate( new EqualPredicate("foo")));
assertTrue(!predicate.evaluate(new TestBean("foo")));
assertTrue(predicate.evaluate(new TestBean("bar")));
}
public void testInstanceOf() {
BeanPredicate predicate =
new BeanPredicate("stringProperty",new InstanceofPredicate( String.class ));
assertTrue(predicate.evaluate(new TestBean("foo")));
assertTrue(predicate.evaluate(new TestBean("bar")));
}
public void testNull() {
BeanPredicate predicate =
new BeanPredicate("stringProperty", NullPredicate.INSTANCE);
String nullString = null;
assertTrue(predicate.evaluate(new TestBean(nullString)));
assertTrue(!predicate.evaluate(new TestBean("bar")));
}
}
././@LongLink 0000000 0000000 0000000 00000000204 00000000000 011561 L ustar root root commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/BeanPropertyValueChangeClosureTest.java commons-beanutils-1.7.0-src/optional/bean-collections/src/test/org/apache/commons/beanutils/BeanPro 0100644 0000766 0000766 00000030063 10047757756 034342 0 ustar crazybull crazybull /*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed 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 org.apache.commons.beanutils;
import junit.framework.TestCase;
/**
* Test cases for <code>BeanPropertyValueChangeClosure</code>.
*
* @author Norm Deane
*/
public class BeanPropertyValueChangeClosureTest extends TestCase {
private static final Integer expectedIntegerValue = new Integer(123);
private static final Float expectedFloatValue = new Float(123.123f);
private static final Double expectedDoubleValue = new Double(567879.12344d);
private static final Boolean expectedBooleanValue = Boolean.TRUE;
private static final Byte expectedByteValue = new Byte("12");
/**
* Constructor for BeanPropertyValueChangeClosureTest.
*
* @param name Name of this test case.
*/
public BeanPropertyValueChangeClosureTest(String name) {
super(name);
}
/**
* Test execute with simple float property and Float value.
*/
public void testExecuteWithSimpleFloatPropertyAndFloatValue() {
TestBean testBean = new TestBean();
new BeanPropertyValueChangeClosure("floatProperty", expectedFloatValue).execute(testBean);
assertTrue(expectedFloatValue.floatValue() == testBean.getFloatProperty());
}
/**
* Test execute with simple float property and String value.
*/
public void testExecuteWithSimpleFloatPropertyAndStringValue() {
try {
new BeanPropertyValueChangeClosure("floatProperty", "123").execute(new TestBean());
fail("Should have thrown an IllegalArgumentException");
} catch (IllegalArgumentException e) {
/* this is what we expect */
}
}
/**
* Test execute with simple float property and Double value.
*/
public void testExecuteWithSimpleFloatPropertyAndDoubleValue() {
try {
new BeanPropertyValueChangeClosure("floatProperty", expectedDoubleValue).execute(new TestBean());
fail("Should have thrown an IllegalArgumentException");
} catch (IllegalArgumentException e) {
/* this is what we expect */
}
}
/**
* Test execute with simple float property and Integer value.
*/
public void testExecuteWithSimpleFloatPropertyAndIntegerValue() {
TestBean testBean = new TestBean();
new BeanPropertyValueChangeClosure("floatProperty", expectedIntegerValue).execute(testBean);
assertTrue(expectedIntegerValue.floatValue() == testBean.getFloatProperty());
}
/**
* Test execute with simple double property and Double value.
*/
public void testExecuteWithSimpleDoublePropertyAndDoubleValue() {
TestBean testBean = new TestBean();
new BeanPropertyValueChangeClosure("doubleProperty", expectedDoubleValue).execute(testBean);
assertTrue(expectedDoubleValue.doubleValue() == testBean.getDoubleProperty());
}
/**
* Test execute with simple double property and String value.
*/
public void testExecuteWithSimpleDoublePropertyAndStringValue() {
try {
new BeanPropertyValueChangeClosure("doubleProperty", "123").execute(new TestBean());
fail("Should have thrown an IllegalArgumentException");
} catch (IllegalArgumentException e) {
/* this is what we expect */
}
}
/**
* Test execute with simple double property and Float value.
*/
public void testExecuteWithSimpleDoublePropertyAndFloatValue() {
TestBean testBean = new TestBean();
new BeanPropertyValueChangeClosure("doubleProperty", expectedFloatValue).execute(testBean);
assertTrue(expectedFloatValue.doubleValue() == testBean.getDoubleProperty());
}
/**
* Test execute with simple double property and Integer value.
*/
public void testExecuteWithSimpleDoublePropertyAndIntegerValue() {
TestBean testBean = new TestBean();
new BeanPropertyValueChangeClosure("doubleProperty", expectedIntegerValue).execute(testBean);
assertTrue(expectedIntegerValue.doubleValue() == testBean.getDoubleProperty());
}
/**
* Test execute with simple int property and Double value.
*/
public void testExecuteWithSimpleIntPropertyAndDoubleValue() {
try {
new BeanPropertyValueChangeClosure("intProperty", expectedDoubleValue).execute(new TestBean());
fail("Should have thrown an IllegalArgumentException");
} catch (IllegalArgumentException 