type, Object value);
}
././@LongLink 100644 0 0 156 12262571655 10270 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/AbstractArrayConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/AbstractArrayConve100644 0 0 16333 12262570611 31104 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.io.IOException;
import java.io.StreamTokenizer;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.beanutils.ConversionException;
import org.apache.commons.beanutils.Converter;
/**
* Convenience base class for converters that translate the String
* representation of an array into a corresponding array of primitives
* object. This class encapsulates the functionality required to parse
* the String into a list of String elements that can later be
* individually converted to the appropriate primitive type.
*
* The input syntax accepted by the parseElements() method
* is designed to be compatible with the syntax used to initialize arrays
* in a Java source program, except that only String literal values are
* supported. For maximum flexibility, the surrounding '{' and '}'
* characters are optional, and individual elements may be separated by
* any combination of whitespace and comma characters.
*
* @version $Id: AbstractArrayConverter.java 1454606 2013-03-08 22:30:51Z britter $
* @since 1.4
* @deprecated Replaced by the new {@link ArrayConverter} implementation
*/
@Deprecated
public abstract class AbstractArrayConverter implements Converter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link Converter} that will throw a {@link ConversionException}
* if a conversion error occurs.
*/
public AbstractArrayConverter() {
this.defaultValue = null;
this.useDefault = false;
}
/**
* Create a {@link Converter} that will return the specified default value
* if a conversion error occurs.
*
* @param defaultValue The default value to be returned
* @since 1.8.0
*/
public AbstractArrayConverter(Object defaultValue) {
if (defaultValue == NO_DEFAULT) {
this.useDefault = false;
} else {
this.defaultValue = defaultValue;
this.useDefault = true;
}
}
// ------------------------------------------------------- Static Variables
/**
* This is a special reference that can be passed as the "default object"
* to the constructor to indicate that no default is desired. Note that
* the value 'null' cannot be used for this purpose, as the caller may
* want a null to be returned as the default.
* @since 1.8.0
*/
public static final Object NO_DEFAULT = new Object();
// ----------------------------------------------------- Instance Variables
/**
* Model object for string arrays.
*/
protected static String[] strings = new String[0];
/**
* The default value specified to our Constructor, if any.
*/
protected Object defaultValue = null;
/**
* Should we return the default value on conversion errors?
*/
protected boolean useDefault = true;
// --------------------------------------------------------- Public Methods
/**
* Convert the specified input object into an output object of the
* specified type. This method must be implemented by a concrete
* subclass.
*
* @param type Data type to which this value should be converted
* @param value The input value to be converted
* @return The converted value
*
* @exception ConversionException if conversion cannot be performed
* successfully
*/
public abstract Object convert(Class type, Object value);
// ------------------------------------------------------ Protected Methods
/**
* Parse an incoming String of the form similar to an array initializer
* in the Java language into a List individual Strings
* for each element, according to the following rules.
*
* The string is expected to be a comma-separated list of values.
* The string may optionally have matching '{' and '}' delimiters
* around the list.
* Whitespace before and after each element is stripped.
* Elements in the list may be delimited by single or double quotes.
* Within a quoted elements, the normal Java escape sequences are valid.
*
*
* @param svalue String value to be parsed
* @return The parsed list of String values
*
* @exception ConversionException if the syntax of svalue
* is not syntactically valid
* @exception NullPointerException if svalue
* is null
*/
protected List parseElements(String svalue) {
// Validate the passed argument
if (svalue == null) {
throw new NullPointerException();
}
// Trim any matching '{' and '}' delimiters
svalue = svalue.trim();
if (svalue.startsWith("{") && svalue.endsWith("}")) {
svalue = svalue.substring(1, svalue.length() - 1);
}
try {
// Set up a StreamTokenizer on the characters in this String
StreamTokenizer st =
new StreamTokenizer(new StringReader(svalue));
st.whitespaceChars(',',','); // Commas are delimiters
st.ordinaryChars('0', '9'); // Needed to turn off numeric flag
st.ordinaryChars('.', '.');
st.ordinaryChars('-', '-');
st.wordChars('0', '9'); // Needed to make part of tokens
st.wordChars('.', '.');
st.wordChars('-', '-');
// Split comma-delimited tokens into a List
ArrayList list = new ArrayList();
while (true) {
int ttype = st.nextToken();
if ((ttype == StreamTokenizer.TT_WORD) ||
(ttype > 0)) {
list.add(st.sval);
} else if (ttype == StreamTokenizer.TT_EOF) {
break;
} else {
throw new ConversionException
("Encountered token of type " + ttype);
}
}
// Return the completed list
return (list);
} catch (IOException e) {
throw new ConversionException(e);
}
}
}
././@LongLink 100644 0 0 151 12262571655 10263 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/AbstractConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/AbstractConverter.100644 0 0 42201 12262570611 31051 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.lang.reflect.Array;
import java.util.Collection;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConversionException;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.Converter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Base {@link Converter} implementation that provides the structure
* for handling conversion to and from a specified type.
*
* This implementation provides the basic structure for
* converting to/from a specified type optionally using a default
* value or throwing a {@link ConversionException} if a
* conversion error occurs.
*
* Implementations should provide conversion to the specified
* type and from the specified type to a String value
* by implementing the following methods:
*
* convertToString(value) - convert to a String
* (default implementation uses the objects toString()
* method).convertToType(Class, value) - convert
* to the specified type
*
* The default value has to be compliant to the default type of this
* converter - which is enforced by the generic type parameter. If a
* conversion is not possible and a default value is set, the converter
* tries to transform the default value to the requested target type.
* If this fails, a {@code ConversionException} if thrown.
*
* @version $Id: AbstractConverter.java 1540518 2013-11-10 19:04:04Z oheger $
* @since 1.8.0
*/
public abstract class AbstractConverter implements Converter {
/** Debug logging message to indicate default value configuration */
private static final String DEFAULT_CONFIG_MSG =
"(N.B. Converters can be configured to use default values to avoid throwing exceptions)";
/** Current package name */
// getPackage() below returns null on some platforms/jvm versions during the unit tests.
// private static final String PACKAGE = AbstractConverter.class.getPackage().getName() + ".";
private static final String PACKAGE = "org.apache.commons.beanutils.converters.";
/**
* Logging for this instance.
*/
private transient Log log;
/**
* Should we return the default value on conversion errors?
*/
private boolean useDefault = false;
/**
* The default value specified to our Constructor, if any.
*/
private Object defaultValue = null;
// ----------------------------------------------------------- Constructors
/**
* Construct a Converter that throws a
* ConversionException if an error occurs.
*/
public AbstractConverter() {
}
/**
* Construct a Converter that returns a default
* value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public AbstractConverter(Object defaultValue) {
setDefaultValue(defaultValue);
}
// --------------------------------------------------------- Public Methods
/**
* Indicates whether a default value will be returned or exception
* thrown in the event of a conversion error.
*
* @return true if a default value will be returned for
* conversion errors or false if a {@link ConversionException}
* will be thrown.
*/
public boolean isUseDefault() {
return useDefault;
}
/**
* Convert the input object into an output object of the
* specified type.
*
* @param the target type of the conversion
* @param type Data type to which this value should be converted
* @param value The input value to be converted
* @return The converted value.
* @throws ConversionException if conversion cannot be performed
* successfully and no default is specified.
*/
public T convert(Class type, Object value) {
if (type == null) {
return convertToDefaultType(type, value);
}
Class sourceType = value == null ? null : value.getClass();
Class targetType = ConvertUtils.primitiveToWrapper(type);
if (log().isDebugEnabled()) {
log().debug("Converting"
+ (value == null ? "" : " '" + toString(sourceType) + "'")
+ " value '" + value + "' to type '" + toString(targetType) + "'");
}
value = convertArray(value);
// Missing Value
if (value == null) {
return handleMissing(targetType);
}
sourceType = value.getClass();
try {
// Convert --> String
if (targetType.equals(String.class)) {
return targetType.cast(convertToString(value));
// No conversion necessary
} else if (targetType.equals(sourceType)) {
if (log().isDebugEnabled()) {
log().debug(" No conversion required, value is already a "
+ toString(targetType));
}
return targetType.cast(value);
// Convert --> Type
} else {
Object result = convertToType(targetType, value);
if (log().isDebugEnabled()) {
log().debug(" Converted to " + toString(targetType) +
" value '" + result + "'");
}
return targetType.cast(result);
}
} catch (Throwable t) {
return handleError(targetType, value, t);
}
}
/**
* Convert the input object into a String.
*
* N.B. This implementation simply uses the value's
* toString() method and should be overriden if a
* more sophisticated mechanism for conversion to a String
* is required.
*
* @param value The input value to be converted.
* @return the converted String value.
* @throws Throwable if an error occurs converting to a String
*/
protected String convertToString(Object value) throws Throwable {
return value.toString();
}
/**
* Convert the input object into an output object of the
* specified type.
*
* Typical implementations will provide a minimum of
* String --> type conversion.
*
* @param Target type of the conversion.
* @param type Data type to which this value should be converted.
* @param value The input value to be converted.
* @return The converted value.
* @throws Throwable if an error occurs converting to the specified type
*/
protected abstract T convertToType(Class type, Object value) throws Throwable;
/**
* Return the first element from an Array (or Collection)
* or the value unchanged if not an Array (or Collection).
*
* N.B. This needs to be overriden for array/Collection converters.
*
* @param value The value to convert
* @return The first element in an Array (or Collection)
* or the value unchanged if not an Array (or Collection)
*/
protected Object convertArray(Object value) {
if (value == null) {
return null;
}
if (value.getClass().isArray()) {
if (Array.getLength(value) > 0) {
return Array.get(value, 0);
} else {
return null;
}
}
if (value instanceof Collection) {
Collection collection = (Collection)value;
if (collection.size() > 0) {
return collection.iterator().next();
} else {
return null;
}
}
return value;
}
/**
* Handle Conversion Errors.
*
* If a default value has been specified then it is returned
* otherwise a ConversionException is thrown.
*
* @param Target type of the conversion.
* @param type Data type to which this value should be converted.
* @param value The input value to be converted
* @param cause The exception thrown by the convert method
* @return The default value.
* @throws ConversionException if no default value has been
* specified for this {@link Converter}.
*/
protected T handleError(Class type, Object value, Throwable cause) {
if (log().isDebugEnabled()) {
if (cause instanceof ConversionException) {
log().debug(" Conversion threw ConversionException: " + cause.getMessage());
} else {
log().debug(" Conversion threw " + cause);
}
}
if (useDefault) {
return handleMissing(type);
}
ConversionException cex = null;
if (cause instanceof ConversionException) {
cex = (ConversionException)cause;
if (log().isDebugEnabled()) {
log().debug(" Re-throwing ConversionException: " + cex.getMessage());
log().debug(" " + DEFAULT_CONFIG_MSG);
}
} else {
String msg = "Error converting from '" + toString(value.getClass()) +
"' to '" + toString(type) + "' " + cause.getMessage();
cex = new ConversionException(msg, cause);
if (log().isDebugEnabled()) {
log().debug(" Throwing ConversionException: " + msg);
log().debug(" " + DEFAULT_CONFIG_MSG);
}
BeanUtils.initCause(cex, cause);
}
throw cex;
}
/**
* Handle missing values.
*
* If a default value has been specified, then it is returned (after a cast
* to the desired target class); otherwise a ConversionException is thrown.
*
* @param the desired target type
* @param type Data type to which this value should be converted.
* @return The default value.
* @throws ConversionException if no default value has been
* specified for this {@link Converter}.
*/
protected T handleMissing(Class type) {
if (useDefault || type.equals(String.class)) {
Object value = getDefault(type);
if (useDefault && value != null && !(type.equals(value.getClass()))) {
try {
value = convertToType(type, defaultValue);
} catch (Throwable t) {
throw new ConversionException("Default conversion to " + toString(type)
+ " failed.", t);
}
}
if (log().isDebugEnabled()) {
log().debug(" Using default "
+ (value == null ? "" : toString(value.getClass()) + " ")
+ "value '" + defaultValue + "'");
}
// value is now either null or of the desired target type
return type.cast(value);
}
ConversionException cex = new ConversionException("No value specified for '" +
toString(type) + "'");
if (log().isDebugEnabled()) {
log().debug(" Throwing ConversionException: " + cex.getMessage());
log().debug(" " + DEFAULT_CONFIG_MSG);
}
throw cex;
}
/**
* Set the default value, converting as required.
*
* If the default value is different from the type the
* Converter handles, it will be converted
* to the handled type.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
* @throws ConversionException if an error occurs converting
* the default value
*/
protected void setDefaultValue(Object defaultValue) {
useDefault = false;
if (log().isDebugEnabled()) {
log().debug("Setting default value: " + defaultValue);
}
if (defaultValue == null) {
this.defaultValue = null;
} else {
this.defaultValue = convert(getDefaultType(), defaultValue);
}
useDefault = true;
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
*/
protected abstract Class getDefaultType();
/**
* Return the default value for conversions to the specified
* type.
* @param type Data type to which this value should be converted.
* @return The default value for the specified type.
*/
protected Object getDefault(Class type) {
if (type.equals(String.class)) {
return null;
} else {
return defaultValue;
}
}
/**
* Provide a String representation of this converter.
*
* @return A String representation of this converter
*/
@Override
public String toString() {
return toString(getClass()) + "[UseDefault=" + useDefault + "]";
}
// ----------------------------------------------------------- Package Methods
/**
* Accessor method for Log instance.
*
* The Log instance variable is transient and
* accessing it through this method ensures it
* is re-initialized when this instance is
* de-serialized.
*
* @return The Log instance.
*/
Log log() {
if (log == null) {
log = LogFactory.getLog(getClass());
}
return log;
}
/**
* Provide a String representation of a java.lang.Class.
* @param type The java.lang.Class.
* @return The String representation.
*/
String toString(Class type) {
String typeName = null;
if (type == null) {
typeName = "null";
} else if (type.isArray()) {
Class elementType = type.getComponentType();
int count = 1;
while (elementType.isArray()) {
elementType = elementType .getComponentType();
count++;
}
typeName = elementType.getName();
for (int i = 0; i < count; i++) {
typeName += "[]";
}
} else {
typeName = type.getName();
}
if (typeName.startsWith("java.lang.") ||
typeName.startsWith("java.util.") ||
typeName.startsWith("java.math.")) {
typeName = typeName.substring("java.lang.".length());
} else if (typeName.startsWith(PACKAGE)) {
typeName = typeName.substring(PACKAGE.length());
}
return typeName;
}
/**
* Performs a conversion to the default type. This method is called if we do
* not have a target class. In this case, the T parameter is not set.
* Therefore, we can cast to it (which is required to fulfill the contract
* of the method signature).
*
* @param the type of the result object
* @param targetClass the target class of the conversion
* @param value the value to be converted
* @return the converted value
*/
private T convertToDefaultType(Class targetClass, Object value) {
@SuppressWarnings("unchecked")
T result = (T) convert(getDefaultType(), value);
return result;
}
/**
* Generates a standard conversion exception with a message indicating that
* the passed in value cannot be converted to the desired target type.
*
* @param type the target type
* @param value the value to be converted
* @return a {@code ConversionException} with a standard message
* @since 1.9
*/
protected ConversionException conversionException(Class type, Object value) {
return new ConversionException("Can't convert value '" + value
+ "' to type " + type);
}
}
././@LongLink 100644 0 0 146 12262571655 10267 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ArrayConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ArrayConverter.jav100644 0 0 46646 12262570611 31106 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.io.IOException;
import java.io.StreamTokenizer;
import java.io.StringReader;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.beanutils.ConversionException;
import org.apache.commons.beanutils.Converter;
/**
* Generic {@link Converter} implementation that handles conversion
* to and from array objects.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* The main features of this implementation are:
*
* Element Conversion - delegates to a {@link Converter},
* appropriate for the type, to convert individual elements
* of the array. This leverages the power of existing converters
* without having to replicate their functionality for converting
* to the element type and removes the need to create a specifc
* array type converters.Arrays or Collections - can convert from either arrays or
* Collections to an array, limited only by the capability
* of the delegate {@link Converter}.Delimited Lists - can Convert to and from a
* delimited list in String format.Conversion to String - converts an array to a
* String in one of two ways: as a delimited list
* or by converting the first element in the array to a String - this
* is controlled by the {@link ArrayConverter#setOnlyFirstToString(boolean)}
* parameter.Multi Dimensional Arrays - it is possible to convert a String
* to a multi-dimensional arrays, by embedding {@link ArrayConverter}
* within each other - see example below.Default Value
* No Default Default values default
* value . The defaultSize parameter controls the
* default value in the following way:
* defaultSize < 0 - default is nulldefaultSize = 0 - default is an array of length zerodefaultSize > 0 - default is an array with a
* length specified by defaultSize (N.B. elements
* in the array will be null)
*
*
*
* Parsing Delimited Lists
* This implementation can convert a delimited list in String format
* into an array of the appropriate type. By default, it uses a comma as the delimiter
* but the following methods can be used to configure parsing:
*
* setDelimiter(char) - allows the character used as
* the delimiter to be configured [default is a comma].setAllowedChars(char[]) - adds additional characters
* (to the default alphabetic/numeric) to those considered to be
* valid token characters.
*
*
* Multi Dimensional Arrays
* It is possible to convert a String to mulit-dimensional arrays by using
* {@link ArrayConverter} as the element {@link Converter}
* within another {@link ArrayConverter}.
*
* For example, the following code demonstrates how to construct a {@link Converter}
* to convert a delimited String into a two dimensional integer array:
*
*
* // Construct an Integer Converter
* IntegerConverter integerConverter = new IntegerConverter();
*
* // Construct an array Converter for an integer array (i.e. int[]) using
* // an IntegerConverter as the element converter.
* // N.B. Uses the default comma (i.e. ",") as the delimiter between individual numbers
* ArrayConverter arrayConverter = new ArrayConverter(int[].class, integerConverter);
*
* // Construct a "Matrix" Converter which converts arrays of integer arrays using
* // the pre-ceeding ArrayConverter as the element Converter.
* // N.B. Uses a semi-colon (i.e. ";") as the delimiter to separate the different sets of numbers.
* // Also the delimiter used by the first ArrayConverter needs to be added to the
* // "allowed characters" for this one.
* ArrayConverter matrixConverter = new ArrayConverter(int[][].class, arrayConverter);
* matrixConverter.setDelimiter(';');
* matrixConverter.setAllowedChars(new char[] {','});
*
* // Do the Conversion
* String matrixString = "11,12,13 ; 21,22,23 ; 31,32,33 ; 41,42,43";
* int[][] result = (int[][])matrixConverter.convert(int[][].class, matrixString);
*
*
* @version $Id: ArrayConverter.java 1540518 2013-11-10 19:04:04Z oheger $
* @since 1.8.0
*/
public class ArrayConverter extends AbstractConverter {
private final Class defaultType;
private final Converter elementConverter;
private int defaultSize;
private char delimiter = ',';
private char[] allowedChars = new char[] {'.', '-'};
private boolean onlyFirstToString = true;
// ----------------------------------------------------------- Constructors
/**
* Construct an array Converter with the specified
* component Converter that throws a
* ConversionException if an error occurs.
*
* @param defaultType The default array type this
* Converter handles
* @param elementConverter Converter used to convert
* individual array elements.
*/
public ArrayConverter(Class defaultType, Converter elementConverter) {
super();
if (defaultType == null) {
throw new IllegalArgumentException("Default type is missing");
}
if (!defaultType.isArray()) {
throw new IllegalArgumentException("Default type must be an array.");
}
if (elementConverter == null) {
throw new IllegalArgumentException("Component Converter is missing.");
}
this.defaultType = defaultType;
this.elementConverter = elementConverter;
}
/**
* Construct an array Converter with the specified
* component Converter that returns a default
* array of the specified size (or null) if an error occurs.
*
* @param defaultType The default array type this
* Converter handles
* @param elementConverter Converter used to convert
* individual array elements.
* @param defaultSize Specifies the size of the default array value or if less
* than zero indicates that a null default value should be used.
*/
public ArrayConverter(Class defaultType, Converter elementConverter, int defaultSize) {
this(defaultType, elementConverter);
this.defaultSize = defaultSize;
Object defaultValue = null;
if (defaultSize >= 0) {
defaultValue = Array.newInstance(defaultType.getComponentType(), defaultSize);
}
setDefaultValue(defaultValue);
}
/**
* Set the delimiter to be used for parsing a delimited String.
*
* @param delimiter The delimiter [default ',']
*/
public void setDelimiter(char delimiter) {
this.delimiter = delimiter;
}
/**
* Set the allowed characters to be used for parsing a delimited String.
*
* @param allowedChars Characters which are to be considered as part of
* the tokens when parsing a delimited String [default is '.' and '-']
*/
public void setAllowedChars(char[] allowedChars) {
this.allowedChars = allowedChars;
}
/**
* Indicates whether converting to a String should create
* a delimited list or just convert the first value.
*
* @param onlyFirstToString true converts only
* the first value in the array to a String, false
* converts all values in the array into a delimited list (default
* is true
*/
public void setOnlyFirstToString(boolean onlyFirstToString) {
this.onlyFirstToString = onlyFirstToString;
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
*/
@Override
protected Class getDefaultType() {
return defaultType;
}
/**
* Handles conversion to a String.
*
* @param value The value to be converted.
* @return the converted String value.
* @throws Throwable if an error occurs converting to a String
*/
@Override
protected String convertToString(Object value) throws Throwable {
int size = 0;
Iterator iterator = null;
Class type = value.getClass();
if (type.isArray()) {
size = Array.getLength(value);
} else {
Collection collection = convertToCollection(type, value);
size = collection.size();
iterator = collection.iterator();
}
if (size == 0) {
return (String)getDefault(String.class);
}
if (onlyFirstToString) {
size = 1;
}
// Create a StringBuffer containing a delimited list of the values
StringBuilder buffer = new StringBuilder();
for (int i = 0; i < size; i++) {
if (i > 0) {
buffer.append(delimiter);
}
Object element = iterator == null ? Array.get(value, i) : iterator.next();
element = elementConverter.convert(String.class, element);
if (element != null) {
buffer.append(element);
}
}
return buffer.toString();
}
/**
* Handles conversion to an array of the specified type.
*
* @param Target type of the conversion.
* @param type The type to which this value should be converted.
* @param value The input value to be converted.
* @return The converted value.
* @throws Throwable if an error occurs converting to the specified type
*/
@Override
protected T convertToType(Class type, Object value) throws Throwable {
if (!type.isArray()) {
throw new ConversionException(toString(getClass())
+ " cannot handle conversion to '"
+ toString(type) + "' (not an array).");
}
// Handle the source
int size = 0;
Iterator iterator = null;
if (value.getClass().isArray()) {
size = Array.getLength(value);
} else {
Collection collection = convertToCollection(type, value);
size = collection.size();
iterator = collection.iterator();
}
// Allocate a new Array
Class componentType = type.getComponentType();
Object newArray = Array.newInstance(componentType, size);
// Convert and set each element in the new Array
for (int i = 0; i < size; i++) {
Object element = iterator == null ? Array.get(value, i) : iterator.next();
// TODO - probably should catch conversion errors and throw
// new exception providing better info back to the user
element = elementConverter.convert(componentType, element);
Array.set(newArray, i, element);
}
@SuppressWarnings("unchecked")
// This is safe because T is an array type and newArray is an array of
// T's component type
T result = (T) newArray;
return result;
}
/**
* Returns the value unchanged.
*
* @param value The value to convert
* @return The value unchanged
*/
@Override
protected Object convertArray(Object value) {
return value;
}
/**
* Converts non-array values to a Collection prior
* to being converted either to an array or a String.
*
*
* {@link Collection} values are returned unchanged
* {@link Number}, {@link Boolean} and {@link java.util.Date}
* values returned as a the only element in a List.
* All other types are converted to a String and parsed
* as a delimited list.
*
*
* N.B. The method is called by both the
* {@link ArrayConverter#convertToType(Class, Object)} and
* {@link ArrayConverter#convertToString(Object)} methods for
* non-array types.
*
* @param type The type to convert the value to
* @param value value to be converted
* @return Collection elements.
*/
protected Collection convertToCollection(Class type, Object value) {
if (value instanceof Collection) {
return (Collection)value;
}
if (value instanceof Number ||
value instanceof Boolean ||
value instanceof java.util.Date) {
List list = new ArrayList(1);
list.add(value);
return list;
}
return parseElements(type, value.toString());
}
/**
* Return the default value for conversions to the specified
* type.
* @param type Data type to which this value should be converted.
* @return The default value for the specified type.
*/
@Override
protected Object getDefault(Class type) {
if (type.equals(String.class)) {
return null;
}
Object defaultValue = super.getDefault(type);
if (defaultValue == null) {
return null;
}
if (defaultValue.getClass().equals(type)) {
return defaultValue;
} else {
return Array.newInstance(type.getComponentType(), defaultSize);
}
}
/**
* Provide a String representation of this array converter.
*
* @return A String representation of this array converter
*/
@Override
public String toString() {
StringBuilder buffer = new StringBuilder();
buffer.append(toString(getClass()));
buffer.append("[UseDefault=");
buffer.append(isUseDefault());
buffer.append(", ");
buffer.append(elementConverter.toString());
buffer.append(']');
return buffer.toString();
}
/**
* Parse an incoming String of the form similar to an array initializer
* in the Java language into a List individual Strings
* for each element, according to the following rules.
*
* The string is expected to be a comma-separated list of values.
* The string may optionally have matching '{' and '}' delimiters
* around the list.
* Whitespace before and after each element is stripped.
* Elements in the list may be delimited by single or double quotes.
* Within a quoted elements, the normal Java escape sequences are valid.
*
*
* @param type The type to convert the value to
* @param value String value to be parsed
* @return List of parsed elements.
*
* @throws ConversionException if the syntax of svalue
* is not syntactically valid
* @throws NullPointerException if svalue
* is null
*/
private List parseElements(Class type, String value) {
if (log().isDebugEnabled()) {
log().debug("Parsing elements, delimiter=[" + delimiter + "], value=[" + value + "]");
}
// Trim any matching '{' and '}' delimiters
value = value.trim();
if (value.startsWith("{") && value.endsWith("}")) {
value = value.substring(1, value.length() - 1);
}
try {
// Set up a StreamTokenizer on the characters in this String
StreamTokenizer st = new StreamTokenizer(new StringReader(value));
st.whitespaceChars(delimiter , delimiter); // Set the delimiters
st.ordinaryChars('0', '9'); // Needed to turn off numeric flag
st.wordChars('0', '9'); // Needed to make part of tokens
for (int i = 0; i < allowedChars.length; i++) {
st.ordinaryChars(allowedChars[i], allowedChars[i]);
st.wordChars(allowedChars[i], allowedChars[i]);
}
// Split comma-delimited tokens into a List
List list = null;
while (true) {
int ttype = st.nextToken();
if ((ttype == StreamTokenizer.TT_WORD) || (ttype > 0)) {
if (st.sval != null) {
if (list == null) {
list = new ArrayList();
}
list.add(st.sval);
}
} else if (ttype == StreamTokenizer.TT_EOF) {
break;
} else {
throw new ConversionException("Encountered token of type "
+ ttype + " parsing elements to '" + toString(type) + ".");
}
}
if (list == null) {
list = Collections.emptyList();
}
if (log().isDebugEnabled()) {
log().debug(list.size() + " elements parsed");
}
// Return the completed list
return (list);
} catch (IOException e) {
throw new ConversionException("Error converting from String to '"
+ toString(type) + "': " + e.getMessage(), e);
}
}
}
././@LongLink 100644 0 0 153 12262571655 10265 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/BigDecimalConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/BigDecimalConverte100644 0 0 4767 12262570611 31025 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.math.BigDecimal;
/**
* {@link NumberConverter} implementation that handles conversion to
* and from java.math.BigDecimal objects.
*
* This implementation can be configured to handle conversion either
* by using BigDecimal's default String conversion, or by using a Locale's pattern
* or by specifying a format pattern. See the {@link NumberConverter}
* documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: BigDecimalConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class BigDecimalConverter extends NumberConverter {
/**
* Construct a java.math.BigDecimal Converter that throws
* a ConversionException if an error occurs.
*/
public BigDecimalConverter() {
super(true);
}
/**
* Construct a java.math.BigDecimal Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public BigDecimalConverter(Object defaultValue) {
super(true, defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return BigDecimal.class;
}
}
././@LongLink 100644 0 0 153 12262571655 10265 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/BigIntegerConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/BigIntegerConverte100644 0 0 4771 12262570611 31057 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.math.BigInteger;
/**
* {@link NumberConverter} implementation that handles conversion to
* and from java.math.BigInteger objects.
*
* This implementation can be configured to handle conversion either
* by using BigInteger's default String conversion, or by using a Locale's pattern
* or by specifying a format pattern. See the {@link NumberConverter}
* documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: BigIntegerConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class BigIntegerConverter extends NumberConverter {
/**
* Construct a java.math.BigInteger Converter that throws
* a ConversionException if an error occurs.
*/
public BigIntegerConverter() {
super(false);
}
/**
* Construct a java.math.BigInteger Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public BigIntegerConverter(Object defaultValue) {
super(false, defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return BigInteger.class;
}
}
././@LongLink 100644 0 0 155 12262571655 10267 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/BooleanArrayConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/BooleanArrayConver100644 0 0 22777 12262570611 31113 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.util.List;
import org.apache.commons.beanutils.ConversionException;
/**
* Standard {@link org.apache.commons.beanutils.Converter} implementation that converts an incoming
* String into a primitive array of boolean. On a conversion failure, returns
* a specified default value or throws a {@link ConversionException} depending
* on how this instance is constructed.
*
* By default, the values to be converted are expected to be those
* recognised by a default instance of BooleanConverter. A customised
* BooleanConverter can be provided in order to recognise alternative values
* as true/false.
*
* @version $Id: BooleanArrayConverter.java 1454606 2013-03-08 22:30:51Z britter $
* @since 1.4
* @deprecated Replaced by the new {@link ArrayConverter} implementation
*/
@Deprecated
public final class BooleanArrayConverter extends AbstractArrayConverter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will throw
* a {@link ConversionException} if a conversion error occurs.
*
* Conversion of strings to boolean values will be done via a default
* instance of class BooleanConverter.
*/
public BooleanArrayConverter() {
super();
this.booleanConverter = DEFAULT_CONVERTER;
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* Conversion of strings to boolean values will be done via a default
* instance of class BooleanConverter.
*
* @param defaultValue The default value to be returned
*/
public BooleanArrayConverter(Object defaultValue) {
super(defaultValue);
this.booleanConverter = DEFAULT_CONVERTER;
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* Conversion of strings to boolean values will be done via the
* specified converter.
*
* @param converter is the converter object that will be used to
* convert each input string-value into a boolean.
*
* @param defaultValue is the default value to be returned by method
* convert if conversion fails; null is a valid default value. See the
* documentation for method "convert" for more information.
* The value BooleanArrayConverter.NO_DEFAULT may be passed here to
* specify that an exception should be thrown on conversion failure.
*
*/
public BooleanArrayConverter(BooleanConverter converter, Object defaultValue) {
super(defaultValue);
this.booleanConverter = converter;
}
// ------------------------------------------------------- Static Variables
/**
* Type which this class converts its input to. This value can be
* used as a parameter to the ConvertUtils.register method.
* @since 1.8.0
*/
public static final Class MODEL = new boolean[0].getClass();
/**
* The converter that all instances of this class will use to
* do individual string->boolean conversions, unless overridden
* in the constructor.
*/
private static final BooleanConverter DEFAULT_CONVERTER
= new BooleanConverter();
// ---------------------------------------------------- Instance Variables
/**
* This object is used to perform the conversion of individual strings
* into Boolean/boolean values.
*/
protected final BooleanConverter booleanConverter;
// --------------------------------------------------------- Public Methods
/**
* Convert the specified input object into an output object of type
* array-of-boolean.
*
* If the input value is null, then the default value specified in the
* constructor is returned. If no such value was provided, then a
* ConversionException is thrown instead.
*
* If the input value is of type String[] then the returned array shall
* be of the same size as this array, with a true or false value in each
* array element depending on the result of applying method
* BooleanConverter.convert to each string.
*
* For all other types of value, the object's toString method is
* expected to return a string containing a comma-separated list of
* values, eg "true, false, true". See the documentation for
* {@link AbstractArrayConverter#parseElements} for more information on
* the exact formats supported.
*
* If the result of value.toString() cannot be split into separate
* words, then the default value is also returned (or an exception thrown).
*
*
* If any of the elements in the value array (or the elements resulting
* from splitting up value.toString) are not recognised by the
* BooleanConverter associated with this object, then what happens depends
* on whether that BooleanConverter has a default value or not: if it does,
* then that unrecognised element is converted into the BooleanConverter's
* default value. If the BooleanConverter does not have a default
* value, then the default value for this object is returned as the
* complete conversion result (not just for the element), or an
* exception is thrown if this object has no default value defined.
*
* @param type is the type to which this value should be converted. In the
* case of this BooleanArrayConverter class, this value is ignored.
*
* @param value is the input value to be converted.
*
* @return an object of type boolean[], or the default value if there was
* any sort of error during conversion and the constructor
* was provided with a default value.
*
* @exception ConversionException if conversion cannot be performed
* successfully and the constructor was not provided with a default
* value to return on conversion failure.
*
* @exception NullPointerException if value is an array, and any of the
* array elements are null.
*/
@Override
public Object convert(Class type, Object value) {
// Deal with a null value
if (value == null) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException("No value specified");
}
}
// Deal with the no-conversion-needed case
if (MODEL == value.getClass()) {
return (value);
}
// Deal with input value as a String array
//
// TODO: use if (value.getClass().isArray() instead...
// this requires casting to Object[], then using values[i].toString()
if (strings.getClass() == value.getClass()) {
try {
String[] values = (String[]) value;
boolean[] results = new boolean[values.length];
for (int i = 0; i < values.length; i++) {
String stringValue = values[i];
Object result = booleanConverter.convert(Boolean.class, stringValue);
results[i] = ((Boolean) result).booleanValue();
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
// We only get here if the input value is not of type String[].
// In this case, we assume value.toString() returns a comma-separated
// sequence of values; see method AbstractArrayConverter.parseElements
// for more information.
try {
List list = parseElements(value.toString());
boolean[] results = new boolean[list.size()];
for (int i = 0; i < results.length; i++) {
String stringValue = (String) list.get(i);
Object result = booleanConverter.convert(Boolean.class, stringValue);
results[i] = ((Boolean) result).booleanValue();
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
}
././@LongLink 100644 0 0 150 12262571655 10262 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/BooleanConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/BooleanConverter.j100644 0 0 23750 12262570611 31047 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
/**
* {@link org.apache.commons.beanutils.Converter} implementation that handles conversion
* to and from Boolean objects.
* {@link org.apache.commons.beanutils.Converter} implementation that
* handles conversion to and from java.lang.Boolean objects.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* By default any object whose string representation is one of the values
* {"yes", "y", "true", "on", "1"} is converted to Boolean.TRUE, and
* string representations {"no", "n", "false", "off", "0"} are converted
* to Boolean.FALSE. The recognised true/false strings can be changed by:
*
* String[] trueStrings = {"oui", "o", "1"};
* String[] falseStrings = {"non", "n", "0"};
* Converter bc = new BooleanConverter(trueStrings, falseStrings);
* ConvertUtils.register(bc, Boolean.class);
* ConvertUtils.register(bc, Boolean.TYPE);
*
* In addition, it is recommended that the BooleanArrayConverter also be
* modified to recognise the same set of values:
*
* Converter bac = new BooleanArrayConverter(bc, BooleanArrayConverter.NO_DEFAULT);
* ConvertUtils.register(bac, bac.MODEL);
*
*
*
* Case is ignored when converting values to true or false.
*
* @version $Id: BooleanConverter.java 1540518 2013-11-10 19:04:04Z oheger $
* @since 1.3
*/
public final class BooleanConverter extends AbstractConverter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will throw a
* {@link org.apache.commons.beanutils.ConversionException}
* if a conversion error occurs, ie the string value being converted is
* not one of the known true strings, nor one of the known false strings.
*/
public BooleanConverter() {
super();
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return the specified default value
* if a conversion error occurs, ie the string value being converted is
* not one of the known true strings, nor one of the known false strings.
*
* @param defaultValue The default value to be returned if the value
* being converted is not recognised. This value may be null, in which
* case null will be returned on conversion failure. When non-null, it is
* expected that this value will be either Boolean.TRUE or Boolean.FALSE.
* The special value BooleanConverter.NO_DEFAULT can also be passed here,
* in which case this constructor acts like the no-argument one.
*/
public BooleanConverter(Object defaultValue) {
super();
if (defaultValue != NO_DEFAULT) {
setDefaultValue(defaultValue);
}
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will throw a
* {@link org.apache.commons.beanutils.ConversionException}
* if a conversion error occurs, ie the string value being converted is
* not one of the known true strings, nor one of the known false strings.
*
* The provided string arrays are copied, so that changes to the elements
* of the array after this call is made do not affect this object.
*
* @param trueStrings is the set of strings which should convert to the
* value Boolean.TRUE. The value null must not be present. Case is
* ignored.
*
* @param falseStrings is the set of strings which should convert to the
* value Boolean.TRUE. The value null must not be present. Case is
* ignored.
* @since 1.8.0
*/
public BooleanConverter(String[] trueStrings, String[] falseStrings) {
super();
this.trueStrings = copyStrings(trueStrings);
this.falseStrings = copyStrings(falseStrings);
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* The provided string arrays are copied, so that changes to the elements
* of the array after this call is made do not affect this object.
*
* @param trueStrings is the set of strings which should convert to the
* value Boolean.TRUE. The value null must not be present. Case is
* ignored.
*
* @param falseStrings is the set of strings which should convert to the
* value Boolean.TRUE. The value null must not be present. Case is
* ignored.
*
* @param defaultValue The default value to be returned if the value
* being converted is not recognised. This value may be null, in which
* case null will be returned on conversion failure. When non-null, it is
* expected that this value will be either Boolean.TRUE or Boolean.FALSE.
* The special value BooleanConverter.NO_DEFAULT can also be passed here,
* in which case an exception will be thrown on conversion failure.
* @since 1.8.0
*/
public BooleanConverter(String[] trueStrings, String[] falseStrings,
Object defaultValue) {
super();
this.trueStrings = copyStrings(trueStrings);
this.falseStrings = copyStrings(falseStrings);
if (defaultValue != NO_DEFAULT) {
setDefaultValue(defaultValue);
}
}
// ----------------------------------------------------- Static Variables
/**
* This is a special reference that can be passed as the "default object"
* to the constructor to indicate that no default is desired. Note that
* the value 'null' cannot be used for this purpose, as the caller may
* want a null to be returned as the default.
* @deprecated Use constructors without default value.
*/
@Deprecated
public static final Object NO_DEFAULT = new Object();
// ----------------------------------------------------- Instance Variables
/**
* The set of strings that are known to map to Boolean.TRUE.
*/
private String[] trueStrings = {"true", "yes", "y", "on", "1"};
/**
* The set of strings that are known to map to Boolean.FALSE.
*/
private String[] falseStrings = {"false", "no", "n", "off", "0"};
// --------------------------------------------------------- Protected Methods
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Boolean.class;
}
/**
* Convert the specified input object into an output object of the
* specified type.
*
* @param Target type of the conversion.
* @param type is the type to which this value should be converted. In the
* case of this BooleanConverter class, this value is ignored.
*
* @param value is the input value to be converted. The toString method
* shall be invoked on this object, and the result compared (ignoring
* case) against the known "true" and "false" string values.
*
* @return Boolean.TRUE if the value was a recognised "true" value,
* Boolean.FALSE if the value was a recognised "false" value, or
* the default value if the value was not recognised and the constructor
* was provided with a default value.
*
* @throws Throwable if an error occurs converting to the specified type
* @since 1.8.0
*/
@Override
protected T convertToType(Class type, Object value) throws Throwable {
if (Boolean.class.equals(type) || Boolean.TYPE.equals(type)) {
// All the values in the trueStrings and falseStrings arrays are
// guaranteed to be lower-case. By converting the input value
// to lowercase too, we can use the efficient String.equals method
// instead of the less-efficient String.equalsIgnoreCase method.
String stringValue = value.toString().toLowerCase();
for (int i = 0; i < trueStrings.length; ++i) {
if (trueStrings[i].equals(stringValue)) {
return type.cast(Boolean.TRUE);
}
}
for (int i = 0; i < falseStrings.length; ++i) {
if (falseStrings[i].equals(stringValue)) {
return type.cast(Boolean.FALSE);
}
}
}
throw conversionException(type, value);
}
/**
* This method creates a copy of the provided array, and ensures that
* all the strings in the newly created array contain only lower-case
* letters.
*
* Using this method to copy string arrays means that changes to the
* src array do not modify the dst array.
*/
private static String[] copyStrings(String[] src) {
String[] dst = new String[src.length];
for(int i=0; iStandard {@link org.apache.commons.beanutils.Converter} implementation that converts an incoming
* String into a primitive array of byte. On a conversion failure, returns
* a specified default value or throws a {@link ConversionException} depending
* on how this instance is constructed.
*
* @version $Id: ByteArrayConverter.java 1454606 2013-03-08 22:30:51Z britter $
* @since 1.4
* @deprecated Replaced by the new {@link ArrayConverter} implementation
*/
@Deprecated
public final class ByteArrayConverter extends AbstractArrayConverter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will
* throw a {@link ConversionException} if a conversion error occurs.
*/
public ByteArrayConverter() {
this.defaultValue = null;
this.useDefault = false;
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* @param defaultValue The default value to be returned
*/
public ByteArrayConverter(Object defaultValue) {
this.defaultValue = defaultValue;
this.useDefault = true;
}
// ------------------------------------------------------- Static Variables
/**
* Model object for type comparisons.
*/
private static final byte[] MODEL = new byte[0];
// --------------------------------------------------------- Public Methods
/**
* Convert the specified input object into an output object of the
* specified type.
*
* @param type Data type to which this value should be converted
* @param value The input value to be converted
* @return the converted value
* @exception ConversionException if conversion cannot be performed
* successfully
*/
@Override
public Object convert(Class type, Object value) {
// Deal with a null value
if (value == null) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException("No value specified");
}
}
// Deal with the no-conversion-needed case
if (MODEL.getClass() == value.getClass()) {
return (value);
}
// Deal with input value as a String array
if (strings.getClass() == value.getClass()) {
try {
String[] values = (String[]) value;
byte[] results = new byte[values.length];
for (int i = 0; i < values.length; i++) {
results[i] = Byte.parseByte(values[i]);
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
// Parse the input value as a String into elements
// and convert to the appropriate type
try {
List list = parseElements(value.toString());
byte[] results = new byte[list.size()];
for (int i = 0; i < results.length; i++) {
results[i] = Byte.parseByte((String) list.get(i));
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
}
././@LongLink 100644 0 0 145 12262571655 10266 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ByteConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ByteConverter.java100644 0 0 4635 12262570611 31044 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
/**
* {@link NumberConverter} implementation that handles conversion to
* and from java.lang.Byte objects.
*
* This implementation can be configured to handle conversion either
* by using Byte's default String conversion, or by using a Locale's pattern
* or by specifying a format pattern. See the {@link NumberConverter}
* documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: ByteConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class ByteConverter extends NumberConverter {
/**
* Construct a java.lang.Byte Converter that throws
* a ConversionException if an error occurs.
*/
public ByteConverter() {
super(false);
}
/**
* Construct a java.lang.Byte Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public ByteConverter(Object defaultValue) {
super(false, defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Byte.class;
}
}
././@LongLink 100644 0 0 151 12262571655 10263 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/CalendarConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/CalendarConverter.100644 0 0 4733 12262570611 31007 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.util.Calendar;
/**
* {@link DateTimeConverter} implementation that handles conversion to
* and from java.util.Calendar objects.
*
* This implementation can be configured to handle conversion either
* by using a Locale's default format or by specifying a set of format
* patterns (note, there is no default String conversion for Calendar).
* See the {@link DateTimeConverter} documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: CalendarConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.8.0
*/
public final class CalendarConverter extends DateTimeConverter {
/**
* Construct a java.util.Calendar Converter that throws
* a ConversionException if an error occurs.
*/
public CalendarConverter() {
super();
}
/**
* Construct a java.util.Calendar Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public CalendarConverter(Object defaultValue) {
super(defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
*/
@Override
protected Class getDefaultType() {
return Calendar.class;
}
}
././@LongLink 100644 0 0 157 12262571655 10271 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/CharacterArrayConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/CharacterArrayConv100644 0 0 11245 12262570611 31065 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.util.List;
import org.apache.commons.beanutils.ConversionException;
/**
*
Standard {@link org.apache.commons.beanutils.Converter} implementation that converts an incoming
* String into a primitive array of char. On a conversion failure, returns
* a specified default value or throws a {@link ConversionException} depending
* on how this instance is constructed.
*
* @version $Id: CharacterArrayConverter.java 1454606 2013-03-08 22:30:51Z britter $
* @since 1.4
* @deprecated Replaced by the new {@link ArrayConverter} implementation
*/
@Deprecated
public final class CharacterArrayConverter extends AbstractArrayConverter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will throw
* a {@link ConversionException} if a conversion error occurs.
*/
public CharacterArrayConverter() {
this.defaultValue = null;
this.useDefault = false;
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* @param defaultValue The default value to be returned
*/
public CharacterArrayConverter(Object defaultValue) {
this.defaultValue = defaultValue;
this.useDefault = true;
}
// ------------------------------------------------------- Static Variables
/**
* Model object for type comparisons.
*/
private static final char[] MODEL = new char[0];
// --------------------------------------------------------- Public Methods
/**
* Convert the specified input object into an output object of the
* specified type.
*
* @param type Data type to which this value should be converted
* @param value The input value to be converted
* @return the converted value
*
* @exception ConversionException if conversion cannot be performed
* successfully
*/
@Override
public Object convert(Class type, Object value) {
// Deal with a null value
if (value == null) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException("No value specified");
}
}
// Deal with the no-conversion-needed case
if (MODEL.getClass() == value.getClass()) {
return (value);
}
// Deal with input value as a String array
if (strings.getClass() == value.getClass()) {
try {
String[] values = (String[]) value;
char[] results = new char[values.length];
for (int i = 0; i < values.length; i++) {
results[i] = values[i].charAt(0);
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
// Parse the input value as a String into elements
// and convert to the appropriate type
try {
List list = parseElements(value.toString());
char[] results = new char[list.size()];
for (int i = 0; i < results.length; i++) {
results[i] = ((String) list.get(i)).charAt(0);
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
}
././@LongLink 100644 0 0 152 12262571655 10264 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/CharacterConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/CharacterConverter100644 0 0 6452 12262570611 31114 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
/**
* {@link org.apache.commons.beanutils.Converter} implementaion that handles conversion
* to and from java.lang.Character objects.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: CharacterConverter.java 1540518 2013-11-10 19:04:04Z oheger $
* @since 1.3
*/
public final class CharacterConverter extends AbstractConverter {
/**
* Construct a java.lang.Character Converter that throws
* a ConversionException if an error occurs.
*/
public CharacterConverter() {
super();
}
/**
* Construct a java.lang.Character Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public CharacterConverter(Object defaultValue) {
super(defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Character.class;
}
/**
*
Convert a java.lang.Class or object into a String.
*
* @param value The input value to be converted
* @return the converted String value.
* @since 1.8.0
*/
@Override
protected String convertToString(Object value) {
String strValue = value.toString();
return strValue.length() == 0 ? "" : strValue.substring(0, 1);
}
/**
* Convert the input object into a java.lang.Character.
*
* @param Target type of the conversion.
* @param type Data type to which this value should be converted.
* @param value The input value to be converted.
* @return The converted value.
* @throws Exception if conversion cannot be performed successfully
* @since 1.8.0
*/
@Override
protected T convertToType(Class type, Object value) throws Exception {
if (Character.class.equals(type) || Character.TYPE.equals(type)) {
return type.cast(new Character(value.toString().charAt(0)));
}
throw conversionException(type, value);
}
}
././@LongLink 100644 0 0 146 12262571655 10267 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ClassConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ClassConverter.jav100644 0 0 7665 12262570611 31053 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
/**
* {@link org.apache.commons.beanutils.Converter} implementaion that handles conversion
* to and from java.lang.Class objects.
*
* The class will be loaded from the thread context class
* loader (if it exists); otherwise the class loader that loaded this class
* will be used.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: ClassConverter.java 1540518 2013-11-10 19:04:04Z oheger $
* @since 1.4
*/
public final class ClassConverter extends AbstractConverter {
/**
* Construct a java.lang.Class Converter that throws
* a ConversionException if an error occurs.
*/
public ClassConverter() {
super();
}
/**
* Construct a java.lang.Class Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public ClassConverter(Object defaultValue) {
super(defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Class.class;
}
/**
*
Convert a java.lang.Class or object into a String.
*
* @param value The input value to be converted
* @return the converted String value.
* @since 1.8.0
*/
@Override
protected String convertToString(Object value) {
return (value instanceof Class) ? ((Class)value).getName() : value.toString();
}
/**
* Convert the input object into a java.lang.Class.
*
* @param Target type of the conversion.
* @param type Data type to which this value should be converted.
* @param value The input value to be converted.
* @return The converted value.
* @throws Throwable if an error occurs converting to the specified type
* @since 1.8.0
*/
@Override
protected T convertToType(Class type, Object value) throws Throwable {
if (Class.class.equals(type)) {
ClassLoader classLoader = Thread.currentThread()
.getContextClassLoader();
if (classLoader != null) {
try {
return type.cast(classLoader.loadClass(value.toString()));
} catch (ClassNotFoundException ex) {
// Don't fail, carry on and try this class's class loader
// (see issue# BEANUTILS-263)
}
}
// Try this class's class loader
classLoader = ClassConverter.class.getClassLoader();
return type.cast(classLoader.loadClass(value.toString()));
}
throw conversionException(type, value);
}
}
././@LongLink 100644 0 0 147 12262571655 10270 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ConverterFacade.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ConverterFacade.ja100644 0 0 5376 12262570611 30760 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import org.apache.commons.beanutils.Converter;
/**
* Provides a facade for {@link Converter} implementations
* preventing access to any public API in the implementation,
* other than that specified by {@link Converter}.
*
* This implementation can be used to prevent registered {@link Converter}
* implementations that provide configuration options from being
* retrieved and modified.
*
* @version $Id: ConverterFacade.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.8.0
*/
public final class ConverterFacade implements Converter {
private final Converter converter;
/**
* Construct a converter which delegates to the specified
* {@link Converter} implementation.
*
* @param converter The converter to delegate to
*/
public ConverterFacade(Converter converter) {
if (converter == null) {
throw new IllegalArgumentException("Converter is missing");
}
this.converter = converter;
}
/**
* Convert the input object into an output object of the
* specified type by delegating to the underlying {@link Converter}
* implementation.
*
* @param The result type of the conversion
* @param type Data type to which this value should be converted
* @param value The input value to be converted
* @return The converted value.
*/
public T convert(Class type, Object value) {
return converter.convert(type, value);
}
/**
* Provide a String representation of this facade implementation
* sand the underlying {@link Converter} it delegates to.
*
* @return A String representation of this facade implementation
* sand the underlying {@link Converter} it delegates to
*/
@Override
public String toString() {
return "ConverterFacade[" + converter.toString() + "]";
}
}
././@LongLink 100644 0 0 145 12262571655 10266 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/DateConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/DateConverter.java100644 0 0 4663 12262570611 31017 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.util.Date;
/**
* {@link DateTimeConverter} implementation that handles conversion to
* and from java.util.Date objects.
*
* This implementation can be configured to handle conversion either
* by using a Locale's default format or by specifying a set of format
* patterns (note, there is no default String conversion for Date).
* See the {@link DateTimeConverter} documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: DateConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.8.0
*/
public final class DateConverter extends DateTimeConverter {
/**
* Construct a java.util.Date Converter that throws
* a ConversionException if an error occurs.
*/
public DateConverter() {
super();
}
/**
* Construct a java.util.Date Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public DateConverter(Object defaultValue) {
super(defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
*/
@Override
protected Class getDefaultType() {
return Date.class;
}
}
././@LongLink 100644 0 0 151 12262571655 10263 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/DateTimeConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/DateTimeConverter.100644 0 0 54527 12262570611 31020 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.text.DateFormat;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
import org.apache.commons.beanutils.ConversionException;
/**
* {@link org.apache.commons.beanutils.Converter} implementaion
* that handles conversion to and from date/time objects.
*
* This implementation handles conversion for the following
* date/time types.
*
* java.util.Datejava.util.Calendarjava.sql.Datejava.sql.Timejava.sql.Timestamp
*
* String Conversions (to and from)
* This class provides a number of ways in which date/time
* conversions to/from Strings can be achieved:
*
* Using the SHORT date format for the default Locale, configure using:
*
* setUseLocaleFormat(true)
* Using the SHORT date format for a specified Locale, configure using:
*
* Using the specified date pattern(s) for the default Locale, configure using:
*
* Either setPattern(String) or
* setPatterns(String[])
*
* Using the specified date pattern(s) for a specified Locale, configure using:
*
* setPattern(String) or
* setPatterns(String[]) and...setLocale(Locale)
* If none of the above are configured the
* toDate(String) method is used to convert
* from String to Date and the Dates's
* toString() method used to convert from
* Date to String.
*
*
*
* The Time Zone to use with the date format can be specified
* using the setTimeZone() method.
*
* @version $Id: DateTimeConverter.java 1546738 2013-11-30 16:24:19Z oheger $
* @since 1.8.0
*/
public abstract class DateTimeConverter extends AbstractConverter {
private String[] patterns;
private String displayPatterns;
private Locale locale;
private TimeZone timeZone;
private boolean useLocaleFormat;
// ----------------------------------------------------------- Constructors
/**
* Construct a Date/Time Converter that throws a
* ConversionException if an error occurs.
*/
public DateTimeConverter() {
super();
}
/**
* Construct a Date/Time Converter that returns a default
* value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public DateTimeConverter(Object defaultValue) {
super(defaultValue);
}
// --------------------------------------------------------- Public Methods
/**
* Indicate whether conversion should use a format/pattern or not.
*
* @param useLocaleFormat true if the format
* for the locale should be used, otherwise false
*/
public void setUseLocaleFormat(boolean useLocaleFormat) {
this.useLocaleFormat = useLocaleFormat;
}
/**
* Return the Time Zone to use when converting dates
* (or null if none specified.
*
* @return The Time Zone.
*/
public TimeZone getTimeZone() {
return timeZone;
}
/**
* Set the Time Zone to use when converting dates.
*
* @param timeZone The Time Zone.
*/
public void setTimeZone(TimeZone timeZone) {
this.timeZone = timeZone;
}
/**
* Return the Locale for the Converter
* (or null if none specified).
*
* @return The locale to use for conversion
*/
public Locale getLocale() {
return locale;
}
/**
* Set the Locale for the Converter .
*
* @param locale The Locale.
*/
public void setLocale(Locale locale) {
this.locale = locale;
setUseLocaleFormat(true);
}
/**
* Set a date format pattern to use to convert
* dates to/from a java.lang.String.
*
* @see SimpleDateFormat
* @param pattern The format pattern.
*/
public void setPattern(String pattern) {
setPatterns(new String[] {pattern});
}
/**
* Return the date format patterns used to convert
* dates to/from a java.lang.String
* (or null if none specified).
*
* @see SimpleDateFormat
* @return Array of format patterns.
*/
public String[] getPatterns() {
return patterns;
}
/**
* Set the date format patterns to use to convert
* dates to/from a java.lang.String.
*
* @see SimpleDateFormat
* @param patterns Array of format patterns.
*/
public void setPatterns(String[] patterns) {
this.patterns = patterns;
if (patterns != null && patterns.length > 1) {
StringBuilder buffer = new StringBuilder();
for (int i = 0; i < patterns.length; i++) {
if (i > 0) {
buffer.append(", ");
}
buffer.append(patterns[i]);
}
displayPatterns = buffer.toString();
}
setUseLocaleFormat(true);
}
// ------------------------------------------------------ Protected Methods
/**
* Convert an input Date/Calendar object into a String.
*
* N.B. If the converter has been configured to with
* one or more patterns (using setPatterns()), then
* the first pattern will be used to format the date into a String.
* Otherwise the default DateFormat for the default locale
* (and style if configured) will be used.
*
* @param value The input value to be converted
* @return the converted String value.
* @throws Throwable if an error occurs converting to a String
*/
@Override
protected String convertToString(Object value) throws Throwable {
Date date = null;
if (value instanceof Date) {
date = (Date)value;
} else if (value instanceof Calendar) {
date = ((Calendar)value).getTime();
} else if (value instanceof Long) {
date = new Date(((Long)value).longValue());
}
String result = null;
if (useLocaleFormat && date != null) {
DateFormat format = null;
if (patterns != null && patterns.length > 0) {
format = getFormat(patterns[0]);
} else {
format = getFormat(locale, timeZone);
}
logFormat("Formatting", format);
result = format.format(date);
if (log().isDebugEnabled()) {
log().debug(" Converted to String using format '" + result + "'");
}
} else {
result = value.toString();
if (log().isDebugEnabled()) {
log().debug(" Converted to String using toString() '" + result + "'");
}
}
return result;
}
/**
* Convert the input object into a Date object of the
* specified type.
*
* This method handles conversions between the following
* types:
*
* java.util.Datejava.util.Calendarjava.sql.Datejava.sql.Timejava.sql.Timestamp
*
* It also handles conversion from a String to
* any of the above types.
*
*
* For String conversion, if the converter has been configured
* with one or more patterns (using setPatterns()), then
* the conversion is attempted with each of the specified patterns.
* Otherwise the default DateFormat for the default locale
* (and style if configured) will be used.
*
* @param The desired target type of the conversion.
* @param targetType Data type to which this value should be converted.
* @param value The input value to be converted.
* @return The converted value.
* @throws Exception if conversion cannot be performed successfully
*/
@Override
protected T convertToType(Class targetType, Object value) throws Exception {
Class sourceType = value.getClass();
// Handle java.sql.Timestamp
if (value instanceof java.sql.Timestamp) {
// ---------------------- JDK 1.3 Fix ----------------------
// N.B. Prior to JDK 1.4 the Timestamp's getTime() method
// didn't include the milliseconds. The following code
// ensures it works consistently accross JDK versions
java.sql.Timestamp timestamp = (java.sql.Timestamp)value;
long timeInMillis = ((timestamp.getTime() / 1000) * 1000);
timeInMillis += timestamp.getNanos() / 1000000;
// ---------------------- JDK 1.3 Fix ----------------------
return toDate(targetType, timeInMillis);
}
// Handle Date (includes java.sql.Date & java.sql.Time)
if (value instanceof Date) {
Date date = (Date)value;
return toDate(targetType, date.getTime());
}
// Handle Calendar
if (value instanceof Calendar) {
Calendar calendar = (Calendar)value;
return toDate(targetType, calendar.getTime().getTime());
}
// Handle Long
if (value instanceof Long) {
Long longObj = (Long)value;
return toDate(targetType, longObj.longValue());
}
// Convert all other types to String & handle
String stringValue = value.toString().trim();
if (stringValue.length() == 0) {
return handleMissing(targetType);
}
// Parse the Date/Time
if (useLocaleFormat) {
Calendar calendar = null;
if (patterns != null && patterns.length > 0) {
calendar = parse(sourceType, targetType, stringValue);
} else {
DateFormat format = getFormat(locale, timeZone);
calendar = parse(sourceType, targetType, stringValue, format);
}
if (Calendar.class.isAssignableFrom(targetType)) {
return targetType.cast(calendar);
} else {
return toDate(targetType, calendar.getTime().getTime());
}
}
// Default String conversion
return toDate(targetType, stringValue);
}
/**
* Convert a long value to the specified Date type for this
* Converter .
*
*
* This method handles conversion to the following types:
*
* java.util.Datejava.util.Calendarjava.sql.Datejava.sql.Timejava.sql.Timestamp
*
* @param The target type
* @param type The Date type to convert to
* @param value The long value to convert.
* @return The converted date value.
*/
private T toDate(Class type, long value) {
// java.util.Date
if (type.equals(Date.class)) {
return type.cast(new Date(value));
}
// java.sql.Date
if (type.equals(java.sql.Date.class)) {
return type.cast(new java.sql.Date(value));
}
// java.sql.Time
if (type.equals(java.sql.Time.class)) {
return type.cast(new java.sql.Time(value));
}
// java.sql.Timestamp
if (type.equals(java.sql.Timestamp.class)) {
return type.cast(new java.sql.Timestamp(value));
}
// java.util.Calendar
if (type.equals(Calendar.class)) {
Calendar calendar = null;
if (locale == null && timeZone == null) {
calendar = Calendar.getInstance();
} else if (locale == null) {
calendar = Calendar.getInstance(timeZone);
} else if (timeZone == null) {
calendar = Calendar.getInstance(locale);
} else {
calendar = Calendar.getInstance(timeZone, locale);
}
calendar.setTime(new Date(value));
calendar.setLenient(false);
return type.cast(calendar);
}
String msg = toString(getClass()) + " cannot handle conversion to '"
+ toString(type) + "'";
if (log().isWarnEnabled()) {
log().warn(" " + msg);
}
throw new ConversionException(msg);
}
/**
* Default String to Date conversion.
*
* This method handles conversion from a String to the following types:
*
* java.sql.Datejava.sql.Timejava.sql.Timestamp
*
* N.B. No default String conversion
* mechanism is provided for java.util.Date
* and java.util.Calendar type.
*
* @param The target type
* @param type The date type to convert to
* @param value The String value to convert.
* @return The converted Number value.
*/
private T toDate(Class type, String value) {
// java.sql.Date
if (type.equals(java.sql.Date.class)) {
try {
return type.cast(java.sql.Date.valueOf(value));
} catch (IllegalArgumentException e) {
throw new ConversionException(
"String must be in JDBC format [yyyy-MM-dd] to create a java.sql.Date");
}
}
// java.sql.Time
if (type.equals(java.sql.Time.class)) {
try {
return type.cast(java.sql.Time.valueOf(value));
} catch (IllegalArgumentException e) {
throw new ConversionException(
"String must be in JDBC format [HH:mm:ss] to create a java.sql.Time");
}
}
// java.sql.Timestamp
if (type.equals(java.sql.Timestamp.class)) {
try {
return type.cast(java.sql.Timestamp.valueOf(value));
} catch (IllegalArgumentException e) {
throw new ConversionException(
"String must be in JDBC format [yyyy-MM-dd HH:mm:ss.fffffffff] " +
"to create a java.sql.Timestamp");
}
}
String msg = toString(getClass()) + " does not support default String to '"
+ toString(type) + "' conversion.";
if (log().isWarnEnabled()) {
log().warn(" " + msg);
log().warn(" (N.B. Re-configure Converter or use alternative implementation)");
}
throw new ConversionException(msg);
}
/**
* Return a DateFormat for the Locale.
* @param locale The Locale to create the Format with (may be null)
* @param timeZone The Time Zone create the Format with (may be null)
*
* @return A Date Format.
*/
protected DateFormat getFormat(Locale locale, TimeZone timeZone) {
DateFormat format = null;
if (locale == null) {
format = DateFormat.getDateInstance(DateFormat.SHORT);
} else {
format = DateFormat.getDateInstance(DateFormat.SHORT, locale);
}
if (timeZone != null) {
format.setTimeZone(timeZone);
}
return format;
}
/**
* Create a date format for the specified pattern.
*
* @param pattern The date pattern
* @return The DateFormat
*/
private DateFormat getFormat(String pattern) {
DateFormat format = new SimpleDateFormat(pattern);
if (timeZone != null) {
format.setTimeZone(timeZone);
}
return format;
}
/**
* Parse a String date value using the set of patterns.
*
* @param sourceType The type of the value being converted
* @param targetType The type to convert the value to.
* @param value The String date value.
*
* @return The converted Date object.
* @throws Exception if an error occurs parsing the date.
*/
private Calendar parse(Class sourceType, Class targetType, String value) throws Exception {
Exception firstEx = null;
for (int i = 0; i < patterns.length; i++) {
try {
DateFormat format = getFormat(patterns[i]);
Calendar calendar = parse(sourceType, targetType, value, format);
return calendar;
} catch (Exception ex) {
if (firstEx == null) {
firstEx = ex;
}
}
}
if (patterns.length > 1) {
throw new ConversionException("Error converting '" + toString(sourceType) + "' to '" + toString(targetType)
+ "' using patterns '" + displayPatterns + "'");
} else {
throw firstEx;
}
}
/**
* Parse a String into a Calendar object
* using the specified DateFormat.
*
* @param sourceType The type of the value being converted
* @param targetType The type to convert the value to
* @param value The String date value.
* @param format The DateFormat to parse the String value.
*
* @return The converted Calendar object.
* @throws ConversionException if the String cannot be converted.
*/
private Calendar parse(Class sourceType, Class targetType, String value, DateFormat format) {
logFormat("Parsing", format);
format.setLenient(false);
ParsePosition pos = new ParsePosition(0);
Date parsedDate = format.parse(value, pos); // ignore the result (use the Calendar)
if (pos.getErrorIndex() >= 0 || pos.getIndex() != value.length() || parsedDate == null) {
String msg = "Error converting '" + toString(sourceType) + "' to '" + toString(targetType) + "'";
if (format instanceof SimpleDateFormat) {
msg += " using pattern '" + ((SimpleDateFormat)format).toPattern() + "'";
}
if (log().isDebugEnabled()) {
log().debug(" " + msg);
}
throw new ConversionException(msg);
}
Calendar calendar = format.getCalendar();
return calendar;
}
/**
* Provide a String representation of this date/time converter.
*
* @return A String representation of this date/time converter
*/
@Override
public String toString() {
StringBuilder buffer = new StringBuilder();
buffer.append(toString(getClass()));
buffer.append("[UseDefault=");
buffer.append(isUseDefault());
buffer.append(", UseLocaleFormat=");
buffer.append(useLocaleFormat);
if (displayPatterns != null) {
buffer.append(", Patterns={");
buffer.append(displayPatterns);
buffer.append('}');
}
if (locale != null) {
buffer.append(", Locale=");
buffer.append(locale);
}
if (timeZone != null) {
buffer.append(", TimeZone=");
buffer.append(timeZone);
}
buffer.append(']');
return buffer.toString();
}
/**
* Log the DateFormat creation.
* @param action The action the format is being used for
* @param format The Date format
*/
private void logFormat(String action, DateFormat format) {
if (log().isDebugEnabled()) {
StringBuilder buffer = new StringBuilder(45);
buffer.append(" ");
buffer.append(action);
buffer.append(" with Format");
if (format instanceof SimpleDateFormat) {
buffer.append("[");
buffer.append(((SimpleDateFormat)format).toPattern());
buffer.append("]");
}
buffer.append(" for ");
if (locale == null) {
buffer.append("default locale");
} else {
buffer.append("locale[");
buffer.append(locale);
buffer.append("]");
}
if (timeZone != null) {
buffer.append(", TimeZone[");
buffer.append(timeZone);
buffer.append("]");
}
log().debug(buffer.toString());
}
}
}
././@LongLink 100644 0 0 154 12262571655 10266 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/DoubleArrayConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/DoubleArrayConvert100644 0 0 11261 12262570611 31114 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.util.List;
import org.apache.commons.beanutils.ConversionException;
/**
* Standard {@link org.apache.commons.beanutils.Converter} implementation that converts an incoming
* String into a primitive array of double. On a conversion failure, returns
* a specified default value or throws a {@link ConversionException} depending
* on how this instance is constructed.
*
* @version $Id: DoubleArrayConverter.java 1454606 2013-03-08 22:30:51Z britter $
* @since 1.4
* @deprecated Replaced by the new {@link ArrayConverter} implementation
*/
@Deprecated
public final class DoubleArrayConverter extends AbstractArrayConverter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will throw
* a {@link ConversionException} if a conversion error occurs.
*/
public DoubleArrayConverter() {
this.defaultValue = null;
this.useDefault = false;
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* @param defaultValue The default value to be returned
*/
public DoubleArrayConverter(Object defaultValue) {
this.defaultValue = defaultValue;
this.useDefault = true;
}
// ------------------------------------------------------- Static Variables
/**
* Model object for type comparisons.
*/
private static final double[] MODEL = new double[0];
// --------------------------------------------------------- Public Methods
/**
* Convert the specified input object into an output object of the
* specified type.
*
* @param type Data type to which this value should be converted
* @param value The input value to be converted
* @return the converted value
* @exception ConversionException if conversion cannot be performed
* successfully
*/
@Override
public Object convert(Class type, Object value) {
// Deal with a null value
if (value == null) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException("No value specified");
}
}
// Deal with the no-conversion-needed case
if (MODEL.getClass() == value.getClass()) {
return (value);
}
// Deal with input value as a String array
if (strings.getClass() == value.getClass()) {
try {
String[] values = (String[]) value;
double[] results = new double[values.length];
for (int i = 0; i < values.length; i++) {
results[i] = Double.parseDouble(values[i]);
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
// Parse the input value as a String into elements
// and convert to the appropriate type
try {
List list = parseElements(value.toString());
double[] results = new double[list.size()];
for (int i = 0; i < results.length; i++) {
results[i] = Double.parseDouble((String) list.get(i));
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
}
././@LongLink 100644 0 0 147 12262571655 10270 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/DoubleConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/DoubleConverter.ja100644 0 0 4657 12262570611 31030 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
/**
* {@link NumberConverter} implementation that handles conversion to
* and from java.lang.Double objects.
*
* This implementation can be configured to handle conversion either
* by using Double's default String conversion, or by using a Locale's pattern
* or by specifying a format pattern. See the {@link NumberConverter}
* documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: DoubleConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class DoubleConverter extends NumberConverter {
/**
* Construct a java.lang.Double Converter that throws
* a ConversionException if an error occurs.
*/
public DoubleConverter() {
super(true);
}
/**
* Construct a java.lang.Double Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public DoubleConverter(Object defaultValue) {
super(true, defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Double.class;
}
}
././@LongLink 100644 0 0 145 12262571655 10266 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/FileConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/FileConverter.java100644 0 0 5512 12262570611 31013 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.io.File;
/**
* {@link org.apache.commons.beanutils.Converter} implementaion that handles conversion
* to and from java.io.File objects.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: FileConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.6
*/
public final class FileConverter extends AbstractConverter {
/**
* Construct a java.io.File Converter that throws
* a ConversionException if an error occurs.
*/
public FileConverter() {
super();
}
/**
* Construct a java.io.File Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public FileConverter(Object defaultValue) {
super(defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return File.class;
}
/**
*
Convert the input object into a java.io.File.
*
* @param The target type of the conversion.
* @param type Data type to which this value should be converted.
* @param value The input value to be converted.
* @return The converted value.
* @throws Throwable if an error occurs converting to the specified type
* @since 1.8.0
*/
@Override
protected T convertToType(Class type, Object value) throws Throwable {
if (File.class.equals(type)) {
return type.cast(new File(value.toString()));
}
throw conversionException(type, value);
}
}
././@LongLink 100644 0 0 153 12262571655 10265 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/FloatArrayConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/FloatArrayConverte100644 0 0 11252 12262570611 31114 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.util.List;
import org.apache.commons.beanutils.ConversionException;
/**
* Standard {@link org.apache.commons.beanutils.Converter} implementation that converts an incoming
* String into a primitive array of float. On a conversion failure, returns
* a specified default value or throws a {@link ConversionException} depending
* on how this instance is constructed.
*
* @version $Id: FloatArrayConverter.java 1454606 2013-03-08 22:30:51Z britter $
* @since 1.4
* @deprecated Replaced by the new {@link ArrayConverter} implementation
*/
@Deprecated
public final class FloatArrayConverter extends AbstractArrayConverter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will throw
* a {@link ConversionException} if a conversion error occurs.
*/
public FloatArrayConverter() {
this.defaultValue = null;
this.useDefault = false;
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* @param defaultValue The default value to be returned
*/
public FloatArrayConverter(Object defaultValue) {
this.defaultValue = defaultValue;
this.useDefault = true;
}
// ------------------------------------------------------- Static Variables
/**
* Model object for type comparisons.
*/
private static final float[] MODEL = new float[0];
// --------------------------------------------------------- Public Methods
/**
* Convert the specified input object into an output object of the
* specified type.
*
* @param type Data type to which this value should be converted
* @param value The input value to be converted
* @return the converted value
*
* @exception ConversionException if conversion cannot be performed
* successfully
*/
@Override
public Object convert(Class type, Object value) {
// Deal with a null value
if (value == null) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException("No value specified");
}
}
// Deal with the no-conversion-needed case
if (MODEL.getClass() == value.getClass()) {
return (value);
}
// Deal with input value as a String array
if (strings.getClass() == value.getClass()) {
try {
String[] values = (String[]) value;
float[] results = new float[values.length];
for (int i = 0; i < values.length; i++) {
results[i] = Float.parseFloat(values[i]);
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
// Parse the input value as a String into elements
// and convert to the appropriate type
try {
List list = parseElements(value.toString());
float[] results = new float[list.size()];
for (int i = 0; i < results.length; i++) {
results[i] = Float.parseFloat((String) list.get(i));
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
}
././@LongLink 100644 0 0 146 12262571655 10267 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/FloatConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/FloatConverter.jav100644 0 0 4645 12262570611 31046 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
/**
* {@link NumberConverter} implementation that handles conversion to
* and from java.lang.Float objects.
*
* This implementation can be configured to handle conversion either
* by using Float's default String conversion, or by using a Locale's pattern
* or by specifying a format pattern. See the {@link NumberConverter}
* documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: FloatConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class FloatConverter extends NumberConverter {
/**
* Construct a java.lang.Float Converter that throws
* a ConversionException if an error occurs.
*/
public FloatConverter() {
super(true);
}
/**
* Construct a java.lang.Float Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public FloatConverter(Object defaultValue) {
super(true, defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Float.class;
}
}
././@LongLink 100644 0 0 155 12262571655 10267 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/IntegerArrayConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/IntegerArrayConver100644 0 0 11244 12262570611 31114 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.util.List;
import org.apache.commons.beanutils.ConversionException;
/**
* Standard {@link org.apache.commons.beanutils.Converter} implementation that converts an incoming
* String into a primitive array of int. On a conversion failure, returns
* a specified default value or throws a {@link ConversionException} depending
* on how this instance is constructed.
*
* @version $Id: IntegerArrayConverter.java 1454606 2013-03-08 22:30:51Z britter $
* @since 1.4
* @deprecated Replaced by the new {@link ArrayConverter} implementation
*/
@Deprecated
public final class IntegerArrayConverter extends AbstractArrayConverter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will throw
* a {@link ConversionException} if a conversion error occurs.
*/
public IntegerArrayConverter() {
this.defaultValue = null;
this.useDefault = false;
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* @param defaultValue The default value to be returned
*/
public IntegerArrayConverter(Object defaultValue) {
this.defaultValue = defaultValue;
this.useDefault = true;
}
// ------------------------------------------------------- Static Variables
/**
* Model object for type comparisons.
*/
private static final int[] MODEL = new int[0];
// --------------------------------------------------------- Public Methods
/**
* Convert the specified input object into an output object of the
* specified type.
*
* @param type Data type to which this value should be converted
* @param value The input value to be converted
* @return the converted value
*
* @exception ConversionException if conversion cannot be performed
* successfully
*/
@Override
public Object convert(Class type, Object value) {
// Deal with a null value
if (value == null) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException("No value specified");
}
}
// Deal with the no-conversion-needed case
if (MODEL.getClass() == value.getClass()) {
return (value);
}
// Deal with input value as a String array
if (strings.getClass() == value.getClass()) {
try {
String[] values = (String[]) value;
int[] results = new int[values.length];
for (int i = 0; i < values.length; i++) {
results[i] = Integer.parseInt(values[i]);
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
// Parse the input value as a String into elements
// and convert to the appropriate type
try {
List list = parseElements(value.toString());
int[] results = new int[list.size()];
for (int i = 0; i < results.length; i++) {
results[i] = Integer.parseInt((String) list.get(i));
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
}
././@LongLink 100644 0 0 150 12262571655 10262 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/IntegerConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/IntegerConverter.j100644 0 0 4673 12262570611 31050 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
/**
* {@link NumberConverter} implementation that handles conversion to
* and from java.lang.Integer objects.
*
* This implementation can be configured to handle conversion either
* by using Integer's default String conversion, or by using a Locale's pattern
* or by specifying a format pattern. See the {@link NumberConverter}
* documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: IntegerConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class IntegerConverter extends NumberConverter {
/**
* Construct a java.lang.Integer Converter that throws
* a ConversionException if an error occurs.
*/
public IntegerConverter() {
super(false);
}
/**
* Construct a java.lang.Integer Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public IntegerConverter(Object defaultValue) {
super(false, defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Integer.class;
}
}
././@LongLink 100644 0 0 152 12262571655 10264 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/LongArrayConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/LongArrayConverter100644 0 0 11233 12262570611 31127 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.util.List;
import org.apache.commons.beanutils.ConversionException;
/**
* Standard {@link org.apache.commons.beanutils.Converter} implementation that converts an incoming
* String into a primitive array of long. On a conversion failure, returns
* a specified default value or throws a {@link ConversionException} depending
* on how this instance is constructed.
*
* @version $Id: LongArrayConverter.java 1454606 2013-03-08 22:30:51Z britter $
* @since 1.4
* @deprecated Replaced by the new {@link ArrayConverter} implementation
*/
@Deprecated
public final class LongArrayConverter extends AbstractArrayConverter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will throw
* a {@link ConversionException} if a conversion error occurs.
*/
public LongArrayConverter() {
this.defaultValue = null;
this.useDefault = false;
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* @param defaultValue The default value to be returned
*/
public LongArrayConverter(Object defaultValue) {
this.defaultValue = defaultValue;
this.useDefault = true;
}
// ------------------------------------------------------- Static Variables
/**
* Model object for type comparisons.
*/
private static final long[] MODEL = new long[0];
// --------------------------------------------------------- Public Methods
/**
* Convert the specified input object into an output object of the
* specified type.
*
* @param type Data type to which this value should be converted
* @param value The input value to be converted
* @return the converted value
*
* @exception ConversionException if conversion cannot be performed
* successfully
*/
@Override
public Object convert(Class type, Object value) {
// Deal with a null value
if (value == null) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException("No value specified");
}
}
// Deal with the no-conversion-needed case
if (MODEL.getClass() == value.getClass()) {
return (value);
}
// Deal with input value as a String array
if (strings.getClass() == value.getClass()) {
try {
String[] values = (String[]) value;
long[] results = new long[values.length];
for (int i = 0; i < values.length; i++) {
results[i] = Long.parseLong(values[i]);
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
// Parse the input value as a String into elements
// and convert to the appropriate type
try {
List list = parseElements(value.toString());
long[] results = new long[list.size()];
for (int i = 0; i < results.length; i++) {
results[i] = Long.parseLong((String) list.get(i));
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
}
././@LongLink 100644 0 0 145 12262571655 10266 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/LongConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/LongConverter.java100644 0 0 4635 12262570611 31040 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
/**
* {@link NumberConverter} implementation that handles conversion to
* and from java.lang.Long objects.
*
* This implementation can be configured to handle conversion either
* by using Long's default String conversion, or by using a Locale's pattern
* or by specifying a format pattern. See the {@link NumberConverter}
* documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: LongConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class LongConverter extends NumberConverter {
/**
* Construct a java.lang.Long Converter that throws
* a ConversionException if an error occurs.
*/
public LongConverter() {
super(false);
}
/**
* Construct a java.lang.Long Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public LongConverter(Object defaultValue) {
super(false, defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Long.class;
}
}
././@LongLink 100644 0 0 147 12262571655 10270 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/NumberConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/NumberConverter.ja100644 0 0 47521 12262570611 31063 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.NumberFormat;
import java.text.ParsePosition;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import org.apache.commons.beanutils.ConversionException;
/**
* {@link org.apache.commons.beanutils.Converter} implementaion that handles conversion
* to and from java.lang.Number objects.
*
* This implementation handles conversion for the following
* java.lang.Number types.
*
* java.lang.Bytejava.lang.Shortjava.lang.Integerjava.lang.Longjava.lang.Floatjava.lang.Doublejava.math.BigDecimaljava.math.BigInteger
*
* String Conversions (to and from)
* This class provides a number of ways in which number
* conversions to/from Strings can be achieved:
*
* Using the default format for the default Locale, configure using:
*
* setUseLocaleFormat(true)
* Using the default format for a specified Locale, configure using:
*
* Using a specified pattern for the default Locale, configure using:
*
* Using a specified pattern for a specified Locale, configure using:
*
* setPattern(String)setLocale(Locale)
* If none of the above are configured the
* toNumber(String) method is used to convert
* from String to Number and the Number's
* toString() method used to convert from
* Number to String.
*
*
*
* N.B. Patterns can only be specified using the standard
* pattern characters and NOT in localized form (see java.text.DecimalFormat).
* For example to cater for number styles used in Germany such as 0.000,00 the pattern
* is specified in the normal form 0,000.00 and the locale set to Locale.GERMANY.
*
* @version $Id: NumberConverter.java 1546738 2013-11-30 16:24:19Z oheger $
* @since 1.8.0
*/
public abstract class NumberConverter extends AbstractConverter {
private static final Integer ZERO = new Integer(0);
private static final Integer ONE = new Integer(1);
private String pattern;
private final boolean allowDecimals;
private boolean useLocaleFormat;
private Locale locale;
// ----------------------------------------------------------- Constructors
/**
* Construct a java.lang.Number Converter
* that throws a ConversionException if a error occurs.
*
* @param allowDecimals Indicates whether decimals are allowed
*/
public NumberConverter(boolean allowDecimals) {
super();
this.allowDecimals = allowDecimals;
}
/**
* Construct a java.lang.Number Converter that returns
* a default value if an error occurs.
*
* @param allowDecimals Indicates whether decimals are allowed
* @param defaultValue The default value to be returned
*/
public NumberConverter(boolean allowDecimals, Object defaultValue) {
super();
this.allowDecimals = allowDecimals;
setDefaultValue(defaultValue);
}
// --------------------------------------------------------- Public Methods
/**
* Return whether decimals are allowed in the number.
*
* @return Whether decimals are allowed in the number
*/
public boolean isAllowDecimals() {
return allowDecimals;
}
/**
* Set whether a format should be used to convert
* the Number.
*
* @param useLocaleFormat true if a number format
* should be used.
*/
public void setUseLocaleFormat(boolean useLocaleFormat) {
this.useLocaleFormat = useLocaleFormat;
}
/**
* Return the number format pattern used to convert
* Numbers to/from a java.lang.String
* (or null if none specified).
*
* See java.text.DecimalFormat for details
* of how to specify the pattern.
*
* @return The format pattern.
*/
public String getPattern() {
return pattern;
}
/**
* Set a number format pattern to use to convert
* Numbers to/from a java.lang.String.
*
* See java.text.DecimalFormat for details
* of how to specify the pattern.
*
* @param pattern The format pattern.
*/
public void setPattern(String pattern) {
this.pattern = pattern;
setUseLocaleFormat(true);
}
/**
* Return the Locale for the Converter
* (or null if none specified).
*
* @return The locale to use for conversion
*/
public Locale getLocale() {
return locale;
}
/**
* Set the Locale for the Converter .
*
* @param locale The locale to use for conversion
*/
public void setLocale(Locale locale) {
this.locale = locale;
setUseLocaleFormat(true);
}
// ------------------------------------------------------ Protected Methods
/**
* Convert an input Number object into a String.
*
* @param value The input value to be converted
* @return the converted String value.
* @throws Throwable if an error occurs converting to a String
*/
@Override
protected String convertToString(Object value) throws Throwable {
String result = null;
if (useLocaleFormat && value instanceof Number) {
NumberFormat format = getFormat();
format.setGroupingUsed(false);
result = format.format(value);
if (log().isDebugEnabled()) {
log().debug(" Converted to String using format '" + result + "'");
}
} else {
result = value.toString();
if (log().isDebugEnabled()) {
log().debug(" Converted to String using toString() '" + result + "'");
}
}
return result;
}
/**
* Convert the input object into a Number object of the
* specified type.
*
* @param Target type of the conversion.
* @param targetType Data type to which this value should be converted.
* @param value The input value to be converted.
* @return The converted value.
* @throws Throwable if an error occurs converting to the specified type
*/
@Override
protected T convertToType(Class targetType, Object value) throws Throwable {
Class sourceType = value.getClass();
// Handle Number
if (value instanceof Number) {
return toNumber(sourceType, targetType, (Number)value);
}
// Handle Boolean
if (value instanceof Boolean) {
return toNumber(sourceType, targetType, ((Boolean)value).booleanValue() ? ONE : ZERO);
}
// Handle Date --> Long
if (value instanceof Date && Long.class.equals(targetType)) {
return targetType.cast(new Long(((Date)value).getTime()));
}
// Handle Calendar --> Long
if (value instanceof Calendar && Long.class.equals(targetType)) {
return targetType.cast(new Long(((Calendar)value).getTime().getTime()));
}
// Convert all other types to String & handle
String stringValue = value.toString().trim();
if (stringValue.length() == 0) {
return handleMissing(targetType);
}
// Convert/Parse a String
Number number = null;
if (useLocaleFormat) {
NumberFormat format = getFormat();
number = parse(sourceType, targetType, stringValue, format);
} else {
if (log().isDebugEnabled()) {
log().debug(" No NumberFormat, using default conversion");
}
number = toNumber(sourceType, targetType, stringValue);
}
// Ensure the correct number type is returned
return toNumber(sourceType, targetType, number);
}
/**
* Convert any Number object to the specified type for this
* Converter .
*
* This method handles conversion to the following types:
*
* java.lang.Bytejava.lang.Shortjava.lang.Integerjava.lang.Longjava.lang.Floatjava.lang.Doublejava.math.BigDecimaljava.math.BigInteger
* @param sourceType The type being converted from
* @param targetType The Number type to convert to
* @param value The Number to convert.
*
* @return The converted value.
*/
private T toNumber(Class sourceType, Class targetType, Number value) {
// Correct Number type already
if (targetType.equals(value.getClass())) {
return targetType.cast(value);
}
// Byte
if (targetType.equals(Byte.class)) {
long longValue = value.longValue();
if (longValue > Byte.MAX_VALUE) {
throw new ConversionException(toString(sourceType) + " value '" + value
+ "' is too large for " + toString(targetType));
}
if (longValue < Byte.MIN_VALUE) {
throw new ConversionException(toString(sourceType) + " value '" + value
+ "' is too small " + toString(targetType));
}
return targetType.cast(new Byte(value.byteValue()));
}
// Short
if (targetType.equals(Short.class)) {
long longValue = value.longValue();
if (longValue > Short.MAX_VALUE) {
throw new ConversionException(toString(sourceType) + " value '" + value
+ "' is too large for " + toString(targetType));
}
if (longValue < Short.MIN_VALUE) {
throw new ConversionException(toString(sourceType) + " value '" + value
+ "' is too small " + toString(targetType));
}
return targetType.cast(new Short(value.shortValue()));
}
// Integer
if (targetType.equals(Integer.class)) {
long longValue = value.longValue();
if (longValue > Integer.MAX_VALUE) {
throw new ConversionException(toString(sourceType) + " value '" + value
+ "' is too large for " + toString(targetType));
}
if (longValue < Integer.MIN_VALUE) {
throw new ConversionException(toString(sourceType) + " value '" + value
+ "' is too small " + toString(targetType));
}
return targetType.cast(new Integer(value.intValue()));
}
// Long
if (targetType.equals(Long.class)) {
return targetType.cast(new Long(value.longValue()));
}
// Float
if (targetType.equals(Float.class)) {
if (value.doubleValue() > Float.MAX_VALUE) {
throw new ConversionException(toString(sourceType) + " value '" + value
+ "' is too large for " + toString(targetType));
}
return targetType.cast(new Float(value.floatValue()));
}
// Double
if (targetType.equals(Double.class)) {
return targetType.cast(new Double(value.doubleValue()));
}
// BigDecimal
if (targetType.equals(BigDecimal.class)) {
if (value instanceof Float || value instanceof Double) {
return targetType.cast(new BigDecimal(value.toString()));
} else if (value instanceof BigInteger) {
return targetType.cast(new BigDecimal((BigInteger)value));
} else {
return targetType.cast(BigDecimal.valueOf(value.longValue()));
}
}
// BigInteger
if (targetType.equals(BigInteger.class)) {
if (value instanceof BigDecimal) {
return targetType.cast(((BigDecimal)value).toBigInteger());
} else {
return targetType.cast(BigInteger.valueOf(value.longValue()));
}
}
String msg = toString(getClass()) + " cannot handle conversion to '"
+ toString(targetType) + "'";
if (log().isWarnEnabled()) {
log().warn(" " + msg);
}
throw new ConversionException(msg);
}
/**
* Default String to Number conversion.
*
* This method handles conversion from a String to the following types:
*
* java.lang.Bytejava.lang.Shortjava.lang.Integerjava.lang.Longjava.lang.Floatjava.lang.Doublejava.math.BigDecimaljava.math.BigInteger
* @param sourceType The type being converted from
* @param targetType The Number type to convert to
* @param value The String value to convert.
*
* @return The converted Number value.
*/
private Number toNumber(Class sourceType, Class targetType, String value) {
// Byte
if (targetType.equals(Byte.class)) {
return new Byte(value);
}
// Short
if (targetType.equals(Short.class)) {
return new Short(value);
}
// Integer
if (targetType.equals(Integer.class)) {
return new Integer(value);
}
// Long
if (targetType.equals(Long.class)) {
return new Long(value);
}
// Float
if (targetType.equals(Float.class)) {
return new Float(value);
}
// Double
if (targetType.equals(Double.class)) {
return new Double(value);
}
// BigDecimal
if (targetType.equals(BigDecimal.class)) {
return new BigDecimal(value);
}
// BigInteger
if (targetType.equals(BigInteger.class)) {
return new BigInteger(value);
}
String msg = toString(getClass()) + " cannot handle conversion from '" +
toString(sourceType) + "' to '" + toString(targetType) + "'";
if (log().isWarnEnabled()) {
log().warn(" " + msg);
}
throw new ConversionException(msg);
}
/**
* Provide a String representation of this number converter.
*
* @return A String representation of this number converter
*/
@Override
public String toString() {
StringBuilder buffer = new StringBuilder();
buffer.append(toString(getClass()));
buffer.append("[UseDefault=");
buffer.append(isUseDefault());
buffer.append(", UseLocaleFormat=");
buffer.append(useLocaleFormat);
if (pattern != null) {
buffer.append(", Pattern=");
buffer.append(pattern);
}
if (locale != null) {
buffer.append(", Locale=");
buffer.append(locale);
}
buffer.append(']');
return buffer.toString();
}
/**
* Return a NumberFormat to use for Conversion.
*
* @return The NumberFormat.
*/
private NumberFormat getFormat() {
NumberFormat format = null;
if (pattern != null) {
if (locale == null) {
if (log().isDebugEnabled()) {
log().debug(" Using pattern '" + pattern + "'");
}
format = new DecimalFormat(pattern);
} else {
if (log().isDebugEnabled()) {
log().debug(" Using pattern '" + pattern + "'" +
" with Locale[" + locale + "]");
}
DecimalFormatSymbols symbols = new DecimalFormatSymbols(locale);
format = new DecimalFormat(pattern, symbols);
}
} else {
if (locale == null) {
if (log().isDebugEnabled()) {
log().debug(" Using default Locale format");
}
format = NumberFormat.getInstance();
} else {
if (log().isDebugEnabled()) {
log().debug(" Using Locale[" + locale + "] format");
}
format = NumberFormat.getInstance(locale);
}
}
if (!allowDecimals) {
format.setParseIntegerOnly(true);
}
return format;
}
/**
* Convert a String into a Number object.
* @param sourceType the source type of the conversion
* @param targetType The type to convert the value to
* @param value The String date value.
* @param format The NumberFormat to parse the String value.
*
* @return The converted Number object.
* @throws ConversionException if the String cannot be converted.
*/
private Number parse(Class sourceType, Class targetType, String value, NumberFormat format) {
ParsePosition pos = new ParsePosition(0);
Number parsedNumber = format.parse(value, pos);
if (pos.getErrorIndex() >= 0 || pos.getIndex() != value.length() || parsedNumber == null) {
String msg = "Error converting from '" + toString(sourceType) + "' to '" + toString(targetType) + "'";
if (format instanceof DecimalFormat) {
msg += " using pattern '" + ((DecimalFormat)format).toPattern() + "'";
}
if (locale != null) {
msg += " for locale=[" + locale + "]";
}
if (log().isDebugEnabled()) {
log().debug(" " + msg);
}
throw new ConversionException(msg);
}
return parsedNumber;
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/package-info.java 100644 0 0 1770 12262570611 30572 0 ustar 0 0 /*
* 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.
*/
/**
* Standard implementations of the {@link Converter} interface that
* are pre-registered with {@link ConvertUtils} at startup time.
*/
package org.apache.commons.beanutils.converters;
././@LongLink 100644 0 0 153 12262571655 10265 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ShortArrayConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ShortArrayConverte100644 0 0 11252 12262570611 31146 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.util.List;
import org.apache.commons.beanutils.ConversionException;
/**
* Standard {@link org.apache.commons.beanutils.Converter} implementation that converts an incoming
* String into a primitive array of short. On a conversion failure, returns
* a specified default value or throws a {@link ConversionException} depending
* on how this instance is constructed.
*
* @version $Id: ShortArrayConverter.java 1454606 2013-03-08 22:30:51Z britter $
* @since 1.4
* @deprecated Replaced by the new {@link ArrayConverter} implementation
*/
@Deprecated
public final class ShortArrayConverter extends AbstractArrayConverter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will throw
* a {@link ConversionException} if a conversion error occurs.
*/
public ShortArrayConverter() {
this.defaultValue = null;
this.useDefault = false;
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* @param defaultValue The default value to be returned
*/
public ShortArrayConverter(Object defaultValue) {
this.defaultValue = defaultValue;
this.useDefault = true;
}
// ------------------------------------------------------- Static Variables
/**
* Model object for type comparisons.
*/
private static final short[] MODEL = new short[0];
// --------------------------------------------------------- Public Methods
/**
* Convert the specified input object into an output object of the
* specified type.
*
* @param type Data type to which this value should be converted
* @param value The input value to be converted
* @return the converted value
*
* @exception ConversionException if conversion cannot be performed
* successfully
*/
@Override
public Object convert(Class type, Object value) {
// Deal with a null value
if (value == null) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException("No value specified");
}
}
// Deal with the no-conversion-needed case
if (MODEL.getClass() == value.getClass()) {
return (value);
}
// Deal with input value as a String array
if (strings.getClass() == value.getClass()) {
try {
String[] values = (String[]) value;
short[] results = new short[values.length];
for (int i = 0; i < values.length; i++) {
results[i] = Short.parseShort(values[i]);
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
// Parse the input value as a String into elements
// and convert to the appropriate type
try {
List list = parseElements(value.toString());
short[] results = new short[list.size()];
for (int i = 0; i < results.length; i++) {
results[i] = Short.parseShort((String) list.get(i));
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
}
././@LongLink 100644 0 0 146 12262571655 10267 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ShortConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/ShortConverter.jav100644 0 0 4647 12262570611 31102 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
/**
* {@link NumberConverter} implementation that handles conversion to
* and from java.lang.Short objects.
*
* This implementation can be configured to handle conversion either
* by using Short's default String conversion, or by using a Locale's pattern
* or by specifying a format pattern. See the {@link NumberConverter}
* documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: ShortConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class ShortConverter extends NumberConverter {
/**
* Construct a java.lang.Short Converter that throws
* a ConversionException if an error occurs.
*/
public ShortConverter() {
super(false);
}
/**
* Construct a java.lang.Short Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public ShortConverter(Object defaultValue) {
super(false, defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Short.class;
}
}
././@LongLink 100644 0 0 150 12262571655 10262 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/SqlDateConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/SqlDateConverter.j100644 0 0 4716 12262570611 31006 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.sql.Date;
/**
* {@link DateTimeConverter} implementation that handles conversion to
* and from java.sql.Date objects.
*
* This implementation can be configured to handle conversion either
* by using java.sql.Date's default String conversion, or by using a
* Locale's default format or by specifying a set of format patterns.
* See the {@link DateTimeConverter} documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: SqlDateConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class SqlDateConverter extends DateTimeConverter {
/**
* Construct a java.sql.Date Converter that throws
* a ConversionException if an error occurs.
*/
public SqlDateConverter() {
super();
}
/**
* Construct a java.sql.Date Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public SqlDateConverter(Object defaultValue) {
super(defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Date.class;
}
}
././@LongLink 100644 0 0 150 12262571655 10262 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/SqlTimeConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/SqlTimeConverter.j100644 0 0 6237 12262570611 31027 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.sql.Time;
import java.text.DateFormat;
import java.util.Locale;
import java.util.TimeZone;
/**
* {@link DateTimeConverter} implementation that handles conversion to
* and from java.sql.Time objects.
*
* This implementation can be configured to handle conversion either
* by using java.sql.Time's default String conversion, or by using a
* Locale's default format or by specifying a set of format patterns.
* See the {@link DateTimeConverter} documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: SqlTimeConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class SqlTimeConverter extends DateTimeConverter {
/**
* Construct a java.sql.Time Converter that throws
* a ConversionException if an error occurs.
*/
public SqlTimeConverter() {
super();
}
/**
* Construct a java.sql.Time Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public SqlTimeConverter(Object defaultValue) {
super(defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Time.class;
}
/**
* Return a DateFormat for the Locale.
* @param locale TODO
* @param timeZone TODO
*
* @return The DateFormat.
* @since 1.8.0
*/
@Override
protected DateFormat getFormat(Locale locale, TimeZone timeZone) {
DateFormat format = null;
if (locale == null) {
format = DateFormat.getTimeInstance(DateFormat.SHORT);
} else {
format = DateFormat.getTimeInstance(DateFormat.SHORT, locale);
}
if (timeZone != null) {
format.setTimeZone(timeZone);
}
return format;
}
}
././@LongLink 100644 0 0 155 12262571655 10267 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/SqlTimestampConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/SqlTimestampConver100644 0 0 6373 12262570611 31132 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.util.Locale;
import java.util.TimeZone;
/**
* {@link DateTimeConverter} implementation that handles conversion to
* and from java.sql.Timestamp objects.
*
* This implementation can be configured to handle conversion either
* by using java.sql.Timestamp's default String conversion, or by using a
* Locale's default format or by specifying a set of format patterns.
* See the {@link DateTimeConverter} documentation for further details.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: SqlTimestampConverter.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.3
*/
public final class SqlTimestampConverter extends DateTimeConverter {
/**
* Construct a java.sql.Timestamp Converter that throws
* a ConversionException if an error occurs.
*/
public SqlTimestampConverter() {
super();
}
/**
* Construct a java.sql.Timestamp Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public SqlTimestampConverter(Object defaultValue) {
super(defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return Timestamp.class;
}
/**
* Return a DateFormat for the Locale.
* @param locale TODO
* @param timeZone TODO
*
* @return The DateFormat.
* @since 1.8.0
*/
@Override
protected DateFormat getFormat(Locale locale, TimeZone timeZone) {
DateFormat format = null;
if (locale == null) {
format = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
} else {
format = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, locale);
}
if (timeZone != null) {
format.setTimeZone(timeZone);
}
return format;
}
}
././@LongLink 100644 0 0 154 12262571655 10266 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/StringArrayConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/StringArrayConvert100644 0 0 13412 12262570611 31150 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.util.List;
import org.apache.commons.beanutils.ConversionException;
/**
* Standard {@link org.apache.commons.beanutils.Converter} implementation that converts an incoming
* String into an array of String objects. On a conversion failure, returns
* a specified default value or throws a {@link ConversionException} depending
* on how this instance is constructed.
*
* There is also some special handling where the input is of type int[].
* See method convert for more details.
*
* @version $Id: StringArrayConverter.java 1454606 2013-03-08 22:30:51Z britter $
* @since 1.4
* @deprecated Replaced by the new {@link ArrayConverter} implementation
*/
@Deprecated
public final class StringArrayConverter extends AbstractArrayConverter {
// ----------------------------------------------------------- Constructors
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will throw
* a {@link ConversionException} if a conversion error occurs.
*/
public StringArrayConverter() {
this.defaultValue = null;
this.useDefault = false;
}
/**
* Create a {@link org.apache.commons.beanutils.Converter} that will return
* the specified default value if a conversion error occurs.
*
* @param defaultValue The default value to be returned
*/
public StringArrayConverter(Object defaultValue) {
this.defaultValue = defaultValue;
this.useDefault = true;
}
// ------------------------------------------------------- Static Variables
/**
*
Model object for type comparisons.
*/
private static final String[] MODEL = new String[0];
/**
* Model object for int arrays.
*/
private static final int[] INT_MODEL = new int[0];
// --------------------------------------------------------- Public Methods
/**
* Convert the specified input object into an output object of the
* specified type.
*
* If the value is already of type String[] then it is simply returned
* unaltered.
*
* If the value is of type int[], then a String[] is returned where each
* element in the string array is the result of calling Integer.toString
* on the corresponding element of the int array. This was added as a
* result of bugzilla request #18297 though there is not complete
* agreement that this feature should have been added.
*
* In all other cases, this method calls toString on the input object, then
* assumes the result is a comma-separated list of values. The values are
* split apart into the individual items and returned as the elements of an
* array. See class AbstractArrayConverter for the exact input formats
* supported.
*
* @param type is the data type to which this value should be converted.
* It is expected to be the class for type String[] (though this parameter
* is actually ignored by this method).
*
* @param value is the input value to be converted. If null then the
* default value is returned or an exception thrown if no default value
* exists.
* @return the converted value
*
* @exception ConversionException if conversion cannot be performed
* successfully, or the input is null and there is no default value set
* for this object.
*/
@Override
public Object convert(Class type, Object value) {
// Deal with a null value
if (value == null) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException("No value specified");
}
}
// Deal with the no-conversion-needed case
if (MODEL.getClass() == value.getClass()) {
return (value);
}
// Deal with the input value as an int array
if (INT_MODEL.getClass() == value.getClass())
{
int[] values = (int[]) value;
String[] results = new String[values.length];
for (int i = 0; i < values.length; i++)
{
results[i] = Integer.toString(values[i]);
}
return (results);
}
// Parse the input value as a String into elements
// and convert to the appropriate type
try {
List list = parseElements(value.toString());
String[] results = new String[list.size()];
for (int i = 0; i < results.length; i++) {
results[i] = (String) list.get(i);
}
return (results);
} catch (Exception e) {
if (useDefault) {
return (defaultValue);
} else {
throw new ConversionException(value.toString(), e);
}
}
}
}
././@LongLink 100644 0 0 147 12262571655 10270 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/StringConverter.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/StringConverter.ja100644 0 0 7420 12262570611 31053 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
/**
* {@link org.apache.commons.beanutils.Converter}
* implementation that converts an incoming
* object into a java.lang.String object.
*
* Note that ConvertUtils really is designed to do string->object conversions,
* and offers very little support for object->string conversions. The
* ConvertUtils/ConvertUtilsBean methods only select a converter to apply
* based upon the target type being converted to, and generally assume that
* the input is a string (by calling its toString method if needed).
*
* This class is therefore just a dummy converter that converts its input
* into a string by calling the input object's toString method and returning
* that value.
*
* It is possible to replace this converter with something that has a big
* if/else statement that selects behaviour based on the real type of the
* object being converted (or possibly has a map of converters, and looks
* them up based on the class of the input object). However this is not part
* of the existing ConvertUtils framework.
*
*
* @version $Id: StringConverter.java 1540518 2013-11-10 19:04:04Z oheger $
* @since 1.3
*/
public final class StringConverter extends AbstractConverter {
/**
* Construct a java.lang.String Converter that throws
* a ConversionException if an error occurs.
*/
public StringConverter() {
super();
}
/**
* Construct a java.lang.String Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public StringConverter(Object defaultValue) {
super(defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return String.class;
}
/**
* Convert the specified input object into an output object of the
* specified type.
*
* @param Target type of the conversion.
* @param type Data type to which this value should be converted.
* @param value The input value to be converted.
* @return The converted value.
* @throws Throwable if an error occurs converting to the specified type
* @since 1.8.0
*/
@Override
protected T convertToType(Class type, Object value) throws Throwable {
// We have to support Object, too, because this class is sometimes
// used for a standard to Object conversion
if (String.class.equals(type) || Object.class.equals(type)) {
return type.cast(value.toString());
}
throw conversionException(type, value);
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/converters/URLConverter.java 100644 0 0 5503 12262570611 30576 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.converters;
import java.net.URL;
/**
* {@link org.apache.commons.beanutils.Converter} implementaion that handles conversion
* to and from java.net.URL objects.
*
* Can be configured to either return a default value or throw a
* ConversionException if a conversion error occurs.
*
* @version $Id: URLConverter.java 1540518 2013-11-10 19:04:04Z oheger $
* @since 1.3
*/
public final class URLConverter extends AbstractConverter {
/**
* Construct a java.net.URL Converter that throws
* a ConversionException if an error occurs.
*/
public URLConverter() {
super();
}
/**
* Construct a java.net.URL Converter that returns
* a default value if an error occurs.
*
* @param defaultValue The default value to be returned
* if the value to be converted is missing or an error
* occurs converting the value.
*/
public URLConverter(Object defaultValue) {
super(defaultValue);
}
/**
* Return the default type this Converter handles.
*
* @return The default type this Converter handles.
* @since 1.8.0
*/
@Override
protected Class getDefaultType() {
return URL.class;
}
/**
*
Convert a java.net.URL or object into a String.
*
* @param Target type of the conversion.
* @param type Data type to which this value should be converted.
* @param value The input value to be converted.
* @return The converted value.
* @throws Throwable if an error occurs converting to the specified type
* @since 1.8.0
*/
@Override
protected T convertToType(Class type, Object value) throws Throwable {
if (URL.class.equals(type)) {
return type.cast(new URL(value.toString()));
}
throw conversionException(type, value);
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/ConvertingWrapDynaBean.java 100644 0 0 6077 12262570611 30433 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
import java.lang.reflect.InvocationTargetException;
/**
* Implementation of DynaBean that wraps a standard JavaBean
* instance, so that DynaBean APIs can be used to access its properties,
* though this implementation allows type conversion to occur when properties are set.
* This means that (say) Strings can be passed in as values in setter methods and
* this DynaBean will convert them to the correct primitive data types.
*
* IMPLEMENTATION NOTE - This implementation does not
* support the contains() and remove() methods.
*
* @version $Id: ConvertingWrapDynaBean.java 1454606 2013-03-08 22:30:51Z britter $
*/
public class ConvertingWrapDynaBean extends WrapDynaBean {
/**
* Construct a new DynaBean associated with the specified
* JavaBean instance.
*
* @param instance JavaBean instance to be wrapped
*/
public ConvertingWrapDynaBean(Object instance) {
super(instance);
}
/**
* Set the value of the property with the specified name
* performing any type conversions if necessary. So this method
* can accept String values for primitive numeric data types for example.
*
* @param name Name of the property whose value is to be set
* @param value Value to which this property is to be set
*
* @exception IllegalArgumentException if there are any problems
* copying the property.
*/
@Override
public void set(String name, Object value) {
try {
BeanUtils.copyProperty(instance, name, value);
} catch (InvocationTargetException ite) {
Throwable cause = ite.getTargetException();
throw new IllegalArgumentException
("Error setting property '" + name +
"' nested exception - " + cause);
} catch (Throwable t) {
IllegalArgumentException iae = new IllegalArgumentException
("Error setting property '" + name +
"', exception - " + t);
BeanUtils.initCause(iae, t);
throw iae;
}
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/ConvertUtils.java 100644 0 0 32755 12262570612 26545 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
/**
* Utility methods for converting String scalar values to objects of the
* specified Class, String arrays to arrays of the specified Class.
*
* For more details, see ConvertUtilsBean which provides the
* implementations for these methods.
*
* @version $Id: ConvertUtils.java 1540518 2013-11-10 19:04:04Z oheger $
* @see ConvertUtilsBean
*/
public class ConvertUtils {
// ------------------------------------------------------ Static Properties
/**
* Gets the default value for Boolean conversions.
* @return The default Boolean value
* @deprecated Register replacement converters for Boolean.TYPE and
* Boolean.class instead
*/
@Deprecated
public static boolean getDefaultBoolean() {
return (ConvertUtilsBean.getInstance().getDefaultBoolean());
}
/**
* Sets the default value for Boolean conversions.
* @param newDefaultBoolean The default Boolean value
* @deprecated Register replacement converters for Boolean.TYPE and
* Boolean.class instead
*/
@Deprecated
public static void setDefaultBoolean(boolean newDefaultBoolean) {
ConvertUtilsBean.getInstance().setDefaultBoolean(newDefaultBoolean);
}
/**
* Gets the default value for Byte conversions.
* @return The default Byte value
* @deprecated Register replacement converters for Byte.TYPE and
* Byte.class instead
*/
@Deprecated
public static byte getDefaultByte() {
return ConvertUtilsBean.getInstance().getDefaultByte();
}
/**
* Sets the default value for Byte conversions.
* @param newDefaultByte The default Byte value
* @deprecated Register replacement converters for Byte.TYPE and
* Byte.class instead
*/
@Deprecated
public static void setDefaultByte(byte newDefaultByte) {
ConvertUtilsBean.getInstance().setDefaultByte(newDefaultByte);
}
/**
* Gets the default value for Character conversions.
* @return The default Character value
* @deprecated Register replacement converters for Character.TYPE and
* Character.class instead
*/
@Deprecated
public static char getDefaultCharacter() {
return ConvertUtilsBean.getInstance().getDefaultCharacter();
}
/**
* Sets the default value for Character conversions.
* @param newDefaultCharacter The default Character value
* @deprecated Register replacement converters for Character.TYPE and
* Character.class instead
*/
@Deprecated
public static void setDefaultCharacter(char newDefaultCharacter) {
ConvertUtilsBean.getInstance().setDefaultCharacter(newDefaultCharacter);
}
/**
* Gets the default value for Double conversions.
* @return The default Double value
* @deprecated Register replacement converters for Double.TYPE and
* Double.class instead
*/
@Deprecated
public static double getDefaultDouble() {
return ConvertUtilsBean.getInstance().getDefaultDouble();
}
/**
* Sets the default value for Double conversions.
* @param newDefaultDouble The default Double value
* @deprecated Register replacement converters for Double.TYPE and
* Double.class instead
*/
@Deprecated
public static void setDefaultDouble(double newDefaultDouble) {
ConvertUtilsBean.getInstance().setDefaultDouble(newDefaultDouble);
}
/**
* Get the default value for Float conversions.
* @return The default Float value
* @deprecated Register replacement converters for Float.TYPE and
* Float.class instead
*/
@Deprecated
public static float getDefaultFloat() {
return ConvertUtilsBean.getInstance().getDefaultFloat();
}
/**
* Sets the default value for Float conversions.
* @param newDefaultFloat The default Float value
* @deprecated Register replacement converters for Float.TYPE and
* Float.class instead
*/
@Deprecated
public static void setDefaultFloat(float newDefaultFloat) {
ConvertUtilsBean.getInstance().setDefaultFloat(newDefaultFloat);
}
/**
* Gets the default value for Integer conversions.
* @return The default Integer value
* @deprecated Register replacement converters for Integer.TYPE and
* Integer.class instead
*/
@Deprecated
public static int getDefaultInteger() {
return ConvertUtilsBean.getInstance().getDefaultInteger();
}
/**
* Sets the default value for Integer conversions.
* @param newDefaultInteger The default Integer value
* @deprecated Register replacement converters for Integer.TYPE and
* Integer.class instead
*/
@Deprecated
public static void setDefaultInteger(int newDefaultInteger) {
ConvertUtilsBean.getInstance().setDefaultInteger(newDefaultInteger);
}
/**
* Gets the default value for Long conversions.
* @return The default Long value
* @deprecated Register replacement converters for Long.TYPE and
* Long.class instead
*/
@Deprecated
public static long getDefaultLong() {
return (ConvertUtilsBean.getInstance().getDefaultLong());
}
/**
* Sets the default value for Long conversions.
* @param newDefaultLong The default Long value
* @deprecated Register replacement converters for Long.TYPE and
* Long.class instead
*/
@Deprecated
public static void setDefaultLong(long newDefaultLong) {
ConvertUtilsBean.getInstance().setDefaultLong(newDefaultLong);
}
/**
* Gets the default value for Short conversions.
* @return The default Short value
* @deprecated Register replacement converters for Short.TYPE and
* Short.class instead
*/
@Deprecated
public static short getDefaultShort() {
return ConvertUtilsBean.getInstance().getDefaultShort();
}
/**
* Sets the default value for Short conversions.
* @param newDefaultShort The default Short value
* @deprecated Register replacement converters for Short.TYPE and
* Short.class instead
*/
@Deprecated
public static void setDefaultShort(short newDefaultShort) {
ConvertUtilsBean.getInstance().setDefaultShort(newDefaultShort);
}
// --------------------------------------------------------- Public Classes
/**
* Convert the specified value into a String.
*
* For more details see ConvertUtilsBean.
*
* @param value Value to be converted (may be null)
* @return The converted String value or null if value is null
*
* @see ConvertUtilsBean#convert(Object)
*/
public static String convert(Object value) {
return ConvertUtilsBean.getInstance().convert(value);
}
/**
* Convert the specified value to an object of the specified class (if
* possible). Otherwise, return a String representation of the value.
*
* For more details see ConvertUtilsBean.
*
* @param value Value to be converted (may be null)
* @param clazz Java class to be converted to (must not be null)
* @return The converted value
*
* @see ConvertUtilsBean#convert(String, Class)
*/
public static Object convert(String value, Class clazz) {
return ConvertUtilsBean.getInstance().convert(value, clazz);
}
/**
* Convert an array of specified values to an array of objects of the
* specified class (if possible).
*
* For more details see ConvertUtilsBean.
*
* @param values Array of values to be converted
* @param clazz Java array or element class to be converted to (must not be null)
* @return The converted value
*
* @see ConvertUtilsBean#convert(String[], Class)
*/
public static Object convert(String[] values, Class clazz) {
return ConvertUtilsBean.getInstance().convert(values, clazz);
}
/**
* Convert the value to an object of the specified class (if
* possible).
*
* @param value Value to be converted (may be null)
* @param targetType Class of the value to be converted to (must not be null)
* @return The converted value
*
* @exception ConversionException if thrown by an underlying Converter
*/
public static Object convert(Object value, Class targetType) {
return ConvertUtilsBean.getInstance().convert(value, targetType);
}
/**
* Remove all registered {@link Converter}s, and re-establish the
* standard Converters.
*
* For more details see ConvertUtilsBean.
*
* @see ConvertUtilsBean#deregister()
*/
public static void deregister() {
ConvertUtilsBean.getInstance().deregister();
}
/**
* Remove any registered {@link Converter} for the specified destination
* Class.
*
* For more details see ConvertUtilsBean.
*
* @param clazz Class for which to remove a registered Converter
* @see ConvertUtilsBean#deregister(Class)
*/
public static void deregister(Class clazz) {
ConvertUtilsBean.getInstance().deregister(clazz);
}
/**
* Look up and return any registered {@link Converter} for the specified
* destination class; if there is no registered Converter, return
* null.
*
* For more details see ConvertUtilsBean.
*
* @param clazz Class for which to return a registered Converter
* @return The registered {@link Converter} or null if not found
* @see ConvertUtilsBean#lookup(Class)
*/
public static Converter lookup(Class clazz) {
return ConvertUtilsBean.getInstance().lookup(clazz);
}
/**
* Look up and return any registered {@link Converter} for the specified
* source and destination class; if there is no registered Converter,
* return null.
*
* @param sourceType Class of the value being converted
* @param targetType Class of the value to be converted to
* @return The registered {@link Converter} or null if not found
*/
public static Converter lookup(Class sourceType, Class targetType) {
return ConvertUtilsBean.getInstance().lookup(sourceType, targetType);
}
/**
* Register a custom {@link Converter} for the specified destination
* Class, replacing any previously registered Converter.
*
* For more details see ConvertUtilsBean.
*
* @param converter Converter to be registered
* @param clazz Destination class for conversions performed by this
* Converter
* @see ConvertUtilsBean#register(Converter, Class)
*/
public static void register(Converter converter, Class clazz) {
ConvertUtilsBean.getInstance().register(converter, clazz);
}
/**
* Change primitive Class types to the associated wrapper class. This is
* useful for concrete converter implementations which typically treat
* primitive types like their corresponding wrapper types.
*
* @param The type to be checked.
* @param type The class type to check.
* @return The converted type.
* @since 1.9
*/
// All type casts are safe because the TYPE members of the wrapper types
// return their own class.
@SuppressWarnings("unchecked")
public static Class primitiveToWrapper(Class type) {
if (type == null || !type.isPrimitive()) {
return type;
}
if (type == Integer.TYPE) {
return (Class) Integer.class;
} else if (type == Double.TYPE) {
return (Class) Double.class;
} else if (type == Long.TYPE) {
return (Class) Long.class;
} else if (type == Boolean.TYPE) {
return (Class) Boolean.class;
} else if (type == Float.TYPE) {
return (Class) Float.class;
} else if (type == Short.TYPE) {
return (Class) Short.class;
} else if (type == Byte.TYPE) {
return (Class) Byte.class;
} else if (type == Character.TYPE) {
return (Class) Character.class;
} else {
return type;
}
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/ConvertUtilsBean.java 100644 0 0 113614 12262570612 27345 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
import java.io.File;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URL;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Collection;
import org.apache.commons.beanutils.converters.ArrayConverter;
import org.apache.commons.beanutils.converters.BigDecimalConverter;
import org.apache.commons.beanutils.converters.BigIntegerConverter;
import org.apache.commons.beanutils.converters.BooleanConverter;
import org.apache.commons.beanutils.converters.ByteConverter;
import org.apache.commons.beanutils.converters.CalendarConverter;
import org.apache.commons.beanutils.converters.CharacterConverter;
import org.apache.commons.beanutils.converters.ClassConverter;
import org.apache.commons.beanutils.converters.ConverterFacade;
import org.apache.commons.beanutils.converters.DateConverter;
import org.apache.commons.beanutils.converters.DoubleConverter;
import org.apache.commons.beanutils.converters.FileConverter;
import org.apache.commons.beanutils.converters.FloatConverter;
import org.apache.commons.beanutils.converters.IntegerConverter;
import org.apache.commons.beanutils.converters.LongConverter;
import org.apache.commons.beanutils.converters.ShortConverter;
import org.apache.commons.beanutils.converters.SqlDateConverter;
import org.apache.commons.beanutils.converters.SqlTimeConverter;
import org.apache.commons.beanutils.converters.SqlTimestampConverter;
import org.apache.commons.beanutils.converters.StringConverter;
import org.apache.commons.beanutils.converters.URLConverter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Utility methods for converting String scalar values to objects of the
* specified Class, String arrays to arrays of the specified Class. The
* actual {@link Converter} instance to be used can be registered for each
* possible destination Class. Unless you override them, standard
* {@link Converter} instances are provided for all of the following
* destination Classes:
*
* java.lang.BigDecimal (no default value)
* java.lang.BigInteger (no default value)
* boolean and java.lang.Boolean (default to false)
* byte and java.lang.Byte (default to zero)
* char and java.lang.Character (default to a space)
* java.lang.Class (no default value)
* double and java.lang.Double (default to zero)
* float and java.lang.Float (default to zero)
* int and java.lang.Integer (default to zero)
* long and java.lang.Long (default to zero)
* short and java.lang.Short (default to zero)
* java.lang.String (default to null)
* java.io.File (no default value)
* java.net.URL (no default value)
* java.sql.Date (no default value)
* java.sql.Time (no default value)
* java.sql.Timestamp (no default value)
*
*
* For backwards compatibility, the standard Converters for primitive
* types (and the corresponding wrapper classes) return a defined
* default value when a conversion error occurs. If you prefer to have a
* {@link ConversionException} thrown instead, replace the standard Converter
* instances with instances created with the zero-arguments constructor. For
* example, to cause the Converters for integers to throw an exception on
* conversion errors, you could do this:
*
* // No-args constructor gets the version that throws exceptions
* Converter myConverter =
* new org.apache.commons.beanutils.converter.IntegerConverter();
* ConvertUtils.register(myConverter, Integer.TYPE); // Native type
* ConvertUtils.register(myConverter, Integer.class); // Wrapper class
*
*
*
* Converters generally treat null input as if it were invalid
* input, ie they return their default value if one was specified when the
* converter was constructed, and throw an exception otherwise. If you prefer
* nulls to be preserved for converters that are converting to objects (not
* primitives) then register a converter as above, passing a default value of
* null to the converter constructor (and of course registering that converter
* only for the .class target).
*
*
*
* When a converter is listed above as having no default value, then that
* converter will throw an exception when passed null or an invalid value
* as its input. In particular, by default the BigInteger and BigDecimal
* converters have no default (and are therefore somewhat inconsistent
* with the other numerical converters which all have zero as their default).
*
*
*
* Converters that generate arrays of each of the primitive types are
* also automatically configured (including String[]). When passed null
* or invalid input, these return an empty array (not null). See class
* AbstractArrayConverter for the supported input formats for these converters.
*
*
* @version $Id: ConvertUtilsBean.java 1540518 2013-11-10 19:04:04Z oheger $
* @since 1.7
*/
public class ConvertUtilsBean {
private static final Integer ZERO = new Integer(0);
private static final Character SPACE = new Character(' ');
// ------------------------------------------------------- Class Methods
/**
* Get singleton instance
* @return The singleton instance
*/
protected static ConvertUtilsBean getInstance() {
return BeanUtilsBean.getInstance().getConvertUtils();
}
// ------------------------------------------------------- Variables
/**
* The set of {@link Converter}s that can be used to convert Strings
* into objects of a specified Class, keyed by the destination Class.
*/
private final WeakFastHashMap, Converter> converters =
new WeakFastHashMap, Converter>();
/**
* The Log instance for this class.
*/
private final Log log = LogFactory.getLog(ConvertUtils.class);
// ------------------------------------------------------- Constructors
/** Construct a bean with standard converters registered */
public ConvertUtilsBean() {
converters.setFast(false);
deregister();
converters.setFast(true);
}
// --------------------------------------------------------- Public Methods
/**
* The default value for Boolean conversions.
* @deprecated Register replacement converters for Boolean.TYPE and
* Boolean.class instead
*/
@Deprecated
private Boolean defaultBoolean = Boolean.FALSE;
/**
* Gets the default value for Boolean conversions.
* @return The default Boolean value
* @deprecated Register replacement converters for Boolean.TYPE and
* Boolean.class instead
*/
@Deprecated
public boolean getDefaultBoolean() {
return (defaultBoolean.booleanValue());
}
/**
* Sets the default value for Boolean conversions.
* @param newDefaultBoolean The default Boolean value
* @deprecated Register replacement converters for Boolean.TYPE and
* Boolean.class instead
*/
@Deprecated
public void setDefaultBoolean(boolean newDefaultBoolean) {
defaultBoolean = (newDefaultBoolean ? Boolean.TRUE : Boolean.FALSE);
register(new BooleanConverter(defaultBoolean), Boolean.TYPE);
register(new BooleanConverter(defaultBoolean), Boolean.class);
}
/**
* The default value for Byte conversions.
* @deprecated Register replacement converters for Byte.TYPE and
* Byte.class instead
*/
@Deprecated
private Byte defaultByte = new Byte((byte) 0);
/**
* Gets the default value for Byte conversions.
* @return The default Byte value
* @deprecated Register replacement converters for Byte.TYPE and
* Byte.class instead
*/
@Deprecated
public byte getDefaultByte() {
return (defaultByte.byteValue());
}
/**
* Sets the default value for Byte conversions.
* @param newDefaultByte The default Byte value
* @deprecated Register replacement converters for Byte.TYPE and
* Byte.class instead
*/
@Deprecated
public void setDefaultByte(byte newDefaultByte) {
defaultByte = new Byte(newDefaultByte);
register(new ByteConverter(defaultByte), Byte.TYPE);
register(new ByteConverter(defaultByte), Byte.class);
}
/**
* The default value for Character conversions.
* @deprecated Register replacement converters for Character.TYPE and
* Character.class instead
*/
@Deprecated
private Character defaultCharacter = new Character(' ');
/**
* Gets the default value for Character conversions.
* @return The default Character value
* @deprecated Register replacement converters for Character.TYPE and
* Character.class instead
*/
@Deprecated
public char getDefaultCharacter() {
return (defaultCharacter.charValue());
}
/**
* Sets the default value for Character conversions.
* @param newDefaultCharacter The default Character value
* @deprecated Register replacement converters for Character.TYPE and
* Character.class instead
*/
@Deprecated
public void setDefaultCharacter(char newDefaultCharacter) {
defaultCharacter = new Character(newDefaultCharacter);
register(new CharacterConverter(defaultCharacter),
Character.TYPE);
register(new CharacterConverter(defaultCharacter),
Character.class);
}
/**
* The default value for Double conversions.
* @deprecated Register replacement converters for Double.TYPE and
* Double.class instead
*/
@Deprecated
private Double defaultDouble = new Double(0.0);
/**
* Gets the default value for Double conversions.
* @return The default Double value
* @deprecated Register replacement converters for Double.TYPE and
* Double.class instead
*/
@Deprecated
public double getDefaultDouble() {
return (defaultDouble.doubleValue());
}
/**
* Sets the default value for Double conversions.
* @param newDefaultDouble The default Double value
* @deprecated Register replacement converters for Double.TYPE and
* Double.class instead
*/
@Deprecated
public void setDefaultDouble(double newDefaultDouble) {
defaultDouble = new Double(newDefaultDouble);
register(new DoubleConverter(defaultDouble), Double.TYPE);
register(new DoubleConverter(defaultDouble), Double.class);
}
/**
* The default value for Float conversions.
* @deprecated Register replacement converters for Float.TYPE and
* Float.class instead
*/
@Deprecated
private Float defaultFloat = new Float((float) 0.0);
/**
* Gets the default value for Float conversions.
* @return The default Float value
* @deprecated Register replacement converters for Float.TYPE and
* Float.class instead
*/
@Deprecated
public float getDefaultFloat() {
return (defaultFloat.floatValue());
}
/**
* Sets the default value for Float conversions.
* @param newDefaultFloat The default Float value
* @deprecated Register replacement converters for Float.TYPE and
* Float.class instead
*/
@Deprecated
public void setDefaultFloat(float newDefaultFloat) {
defaultFloat = new Float(newDefaultFloat);
register(new FloatConverter(defaultFloat), Float.TYPE);
register(new FloatConverter(defaultFloat), Float.class);
}
/**
* The default value for Integer conversions.
* @deprecated Register replacement converters for Integer.TYPE and
* Integer.class instead
*/
@Deprecated
private Integer defaultInteger = new Integer(0);
/**
* Gets the default value for Integer conversions.
* @return The default Integer value
* @deprecated Register replacement converters for Integer.TYPE and
* Integer.class instead
*/
@Deprecated
public int getDefaultInteger() {
return (defaultInteger.intValue());
}
/**
* Sets the default value for Integer conversions.
* @param newDefaultInteger The default Integer value
* @deprecated Register replacement converters for Integer.TYPE and
* Integer.class instead
*/
@Deprecated
public void setDefaultInteger(int newDefaultInteger) {
defaultInteger = new Integer(newDefaultInteger);
register(new IntegerConverter(defaultInteger), Integer.TYPE);
register(new IntegerConverter(defaultInteger), Integer.class);
}
/**
* The default value for Long conversions.
* @deprecated Register replacement converters for Long.TYPE and
* Long.class instead
*/
@Deprecated
private Long defaultLong = new Long(0);
/**
* Gets the default value for Long conversions.
* @return The default Long value
* @deprecated Register replacement converters for Long.TYPE and
* Long.class instead
*/
@Deprecated
public long getDefaultLong() {
return (defaultLong.longValue());
}
/**
* Sets the default value for Long conversions.
* @param newDefaultLong The default Long value
* @deprecated Register replacement converters for Long.TYPE and
* Long.class instead
*/
@Deprecated
public void setDefaultLong(long newDefaultLong) {
defaultLong = new Long(newDefaultLong);
register(new LongConverter(defaultLong), Long.TYPE);
register(new LongConverter(defaultLong), Long.class);
}
/**
* The default value for Short conversions.
* @deprecated Register replacement converters for Short.TYPE and
* Short.class instead
*/
@Deprecated
private static Short defaultShort = new Short((short) 0);
/**
* Gets the default value for Short conversions.
* @return The default Short value
* @deprecated Register replacement converters for Short.TYPE and
* Short.class instead
*/
@Deprecated
public short getDefaultShort() {
return (defaultShort.shortValue());
}
/**
* Sets the default value for Short conversions.
* @param newDefaultShort The default Short value
* @deprecated Register replacement converters for Short.TYPE and
* Short.class instead
*/
@Deprecated
public void setDefaultShort(short newDefaultShort) {
defaultShort = new Short(newDefaultShort);
register(new ShortConverter(defaultShort), Short.TYPE);
register(new ShortConverter(defaultShort), Short.class);
}
/**
* Convert the specified value into a String. If the specified value
* is an array, the first element (converted to a String) will be
* returned. The registered {@link Converter} for the
* java.lang.String class will be used, which allows
* applications to customize Object->String conversions (the default
* implementation simply uses toString()).
*
* @param value Value to be converted (may be null)
* @return The converted String value or null if value is null
*/
public String convert(Object value) {
if (value == null) {
return null;
} else if (value.getClass().isArray()) {
if (Array.getLength(value) < 1) {
return (null);
}
value = Array.get(value, 0);
if (value == null) {
return null;
} else {
Converter converter = lookup(String.class);
return (converter.convert(String.class, value));
}
} else {
Converter converter = lookup(String.class);
return (converter.convert(String.class, value));
}
}
/**
* Convert the specified value to an object of the specified class (if
* possible). Otherwise, return a String representation of the value.
*
* @param value Value to be converted (may be null)
* @param clazz Java class to be converted to (must not be null)
* @return The converted value
*
* @exception ConversionException if thrown by an underlying Converter
*/
public Object convert(String value, Class clazz) {
if (log.isDebugEnabled()) {
log.debug("Convert string '" + value + "' to class '" +
clazz.getName() + "'");
}
Converter converter = lookup(clazz);
if (converter == null) {
converter = lookup(String.class);
}
if (log.isTraceEnabled()) {
log.trace(" Using converter " + converter);
}
return (converter.convert(clazz, value));
}
/**
* Convert an array of specified values to an array of objects of the
* specified class (if possible). If the specified Java class is itself
* an array class, this class will be the type of the returned value.
* Otherwise, an array will be constructed whose component type is the
* specified class.
*
* @param values Array of values to be converted
* @param clazz Java array or element class to be converted to (must not be null)
* @return The converted value
*
* @exception ConversionException if thrown by an underlying Converter
*/
public Object convert(String[] values, Class clazz) {
Class type = clazz;
if (clazz.isArray()) {
type = clazz.getComponentType();
}
if (log.isDebugEnabled()) {
log.debug("Convert String[" + values.length + "] to class '" +
type.getName() + "[]'");
}
Converter converter = lookup(type);
if (converter == null) {
converter = lookup(String.class);
}
if (log.isTraceEnabled()) {
log.trace(" Using converter " + converter);
}
Object array = Array.newInstance(type, values.length);
for (int i = 0; i < values.length; i++) {
Array.set(array, i, converter.convert(type, values[i]));
}
return (array);
}
/**
* Convert the value to an object of the specified class (if
* possible). If no converter for the desired target type is registered,
* the passed in object is returned unchanged.
*
* @param value Value to be converted (may be null)
* @param targetType Class of the value to be converted to (must not be null)
* @return The converted value
*
* @exception ConversionException if thrown by an underlying Converter
*/
public Object convert(Object value, Class targetType) {
Class sourceType = value == null ? null : value.getClass();
if (log.isDebugEnabled()) {
if (value == null) {
log.debug("Convert null value to type '" +
targetType.getName() + "'");
} else {
log.debug("Convert type '" + sourceType.getName() + "' value '" + value +
"' to type '" + targetType.getName() + "'");
}
}
Object converted = value;
Converter converter = lookup(sourceType, targetType);
if (converter != null) {
if (log.isTraceEnabled()) {
log.trace(" Using converter " + converter);
}
converted = converter.convert(targetType, value);
}
if (String.class.equals(targetType) && converted != null &&
!(converted instanceof String)) {
// NOTE: For backwards compatibility, if the Converter
// doesn't handle conversion-->String then
// use the registered String Converter
converter = lookup(String.class);
if (converter != null) {
if (log.isTraceEnabled()) {
log.trace(" Using converter " + converter);
}
converted = converter.convert(String.class, converted);
}
// If the object still isn't a String, use toString() method
if (converted != null && !(converted instanceof String)) {
converted = converted.toString();
}
}
return converted;
}
/**
* Remove all registered {@link Converter}s, and re-establish the
* standard Converters.
*/
public void deregister() {
converters.clear();
registerPrimitives(false);
registerStandard(false, false);
registerOther(true);
registerArrays(false, 0);
register(BigDecimal.class, new BigDecimalConverter());
register(BigInteger.class, new BigIntegerConverter());
}
/**
* Register the provided converters with the specified defaults.
*
* @param throwException true if the converters should
* throw an exception when a conversion error occurs, otherwise
* false if a default value should be used.
* @param defaultNull trueif the standard converters
* (see {@link ConvertUtilsBean#registerStandard(boolean, boolean)})
* should use a default value of null, otherwise false.
* N.B. This values is ignored if throwException is true
* @param defaultArraySize The size of the default array value for array converters
* (N.B. This values is ignored if throwException is true).
* Specifying a value less than zero causes a null value to be used for
* the default.
*/
public void register(boolean throwException, boolean defaultNull, int defaultArraySize) {
registerPrimitives(throwException);
registerStandard(throwException, defaultNull);
registerOther(throwException);
registerArrays(throwException, defaultArraySize);
}
/**
* Register the converters for primitive types.
*
* This method registers the following converters:
*
* Boolean.TYPE - {@link BooleanConverter}Byte.TYPE - {@link ByteConverter}Character.TYPE - {@link CharacterConverter}Double.TYPE - {@link DoubleConverter}Float.TYPE - {@link FloatConverter}Integer.TYPE - {@link IntegerConverter}Long.TYPE - {@link LongConverter}Short.TYPE - {@link ShortConverter}
* @param throwException true if the converters should
* throw an exception when a conversion error occurs, otherwise
* false if a default value should be used.
*/
private void registerPrimitives(boolean throwException) {
register(Boolean.TYPE, throwException ? new BooleanConverter() : new BooleanConverter(Boolean.FALSE));
register(Byte.TYPE, throwException ? new ByteConverter() : new ByteConverter(ZERO));
register(Character.TYPE, throwException ? new CharacterConverter() : new CharacterConverter(SPACE));
register(Double.TYPE, throwException ? new DoubleConverter() : new DoubleConverter(ZERO));
register(Float.TYPE, throwException ? new FloatConverter() : new FloatConverter(ZERO));
register(Integer.TYPE, throwException ? new IntegerConverter() : new IntegerConverter(ZERO));
register(Long.TYPE, throwException ? new LongConverter() : new LongConverter(ZERO));
register(Short.TYPE, throwException ? new ShortConverter() : new ShortConverter(ZERO));
}
/**
* Register the converters for standard types.
*
* This method registers the following converters:
*
* BigDecimal.class - {@link BigDecimalConverter}BigInteger.class - {@link BigIntegerConverter}Boolean.class - {@link BooleanConverter}Byte.class - {@link ByteConverter}Character.class - {@link CharacterConverter}Double.class - {@link DoubleConverter}Float.class - {@link FloatConverter}Integer.class - {@link IntegerConverter}Long.class - {@link LongConverter}Short.class - {@link ShortConverter}String.class - {@link StringConverter}
* @param throwException true if the converters should
* throw an exception when a conversion error occurs, otherwise
* false if a default value should be used.
* @param defaultNull trueif the standard converters
* (see {@link ConvertUtilsBean#registerStandard(boolean, boolean)})
* should use a default value of null, otherwise false.
* N.B. This values is ignored if throwException is true
*/
private void registerStandard(boolean throwException, boolean defaultNull) {
Number defaultNumber = defaultNull ? null : ZERO;
BigDecimal bigDecDeflt = defaultNull ? null : new BigDecimal("0.0");
BigInteger bigIntDeflt = defaultNull ? null : new BigInteger("0");
Boolean booleanDefault = defaultNull ? null : Boolean.FALSE;
Character charDefault = defaultNull ? null : SPACE;
String stringDefault = defaultNull ? null : "";
register(BigDecimal.class, throwException ? new BigDecimalConverter() : new BigDecimalConverter(bigDecDeflt));
register(BigInteger.class, throwException ? new BigIntegerConverter() : new BigIntegerConverter(bigIntDeflt));
register(Boolean.class, throwException ? new BooleanConverter() : new BooleanConverter(booleanDefault));
register(Byte.class, throwException ? new ByteConverter() : new ByteConverter(defaultNumber));
register(Character.class, throwException ? new CharacterConverter() : new CharacterConverter(charDefault));
register(Double.class, throwException ? new DoubleConverter() : new DoubleConverter(defaultNumber));
register(Float.class, throwException ? new FloatConverter() : new FloatConverter(defaultNumber));
register(Integer.class, throwException ? new IntegerConverter() : new IntegerConverter(defaultNumber));
register(Long.class, throwException ? new LongConverter() : new LongConverter(defaultNumber));
register(Short.class, throwException ? new ShortConverter() : new ShortConverter(defaultNumber));
register(String.class, throwException ? new StringConverter() : new StringConverter(stringDefault));
}
/**
* Register the converters for other types.
*
* This method registers the following converters:
*
* Class.class - {@link ClassConverter}java.util.Date.class - {@link DateConverter}java.util.Calendar.class - {@link CalendarConverter}File.class - {@link FileConverter}java.sql.Date.class - {@link SqlDateConverter}java.sql.Time.class - {@link SqlTimeConverter}java.sql.Timestamp.class - {@link SqlTimestampConverter}URL.class - {@link URLConverter}
* @param throwException true if the converters should
* throw an exception when a conversion error occurs, otherwise
* false if a default value should be used.
*/
private void registerOther(boolean throwException) {
register(Class.class, throwException ? new ClassConverter() : new ClassConverter(null));
register(java.util.Date.class, throwException ? new DateConverter() : new DateConverter(null));
register(Calendar.class, throwException ? new CalendarConverter() : new CalendarConverter(null));
register(File.class, throwException ? new FileConverter() : new FileConverter(null));
register(java.sql.Date.class, throwException ? new SqlDateConverter() : new SqlDateConverter(null));
register(java.sql.Time.class, throwException ? new SqlTimeConverter() : new SqlTimeConverter(null));
register(Timestamp.class, throwException ? new SqlTimestampConverter() : new SqlTimestampConverter(null));
register(URL.class, throwException ? new URLConverter() : new URLConverter(null));
}
/**
* Register array converters.
*
* @param throwException true if the converters should
* throw an exception when a conversion error occurs, otherwise
* false if a default value should be used.
* @param defaultArraySize The size of the default array value for array converters
* (N.B. This values is ignored if throwException is true).
* Specifying a value less than zero causes a null value to be used for
* the default.
*/
private void registerArrays(boolean throwException, int defaultArraySize) {
// Primitives
registerArrayConverter(Boolean.TYPE, new BooleanConverter(), throwException, defaultArraySize);
registerArrayConverter(Byte.TYPE, new ByteConverter(), throwException, defaultArraySize);
registerArrayConverter(Character.TYPE, new CharacterConverter(), throwException, defaultArraySize);
registerArrayConverter(Double.TYPE, new DoubleConverter(), throwException, defaultArraySize);
registerArrayConverter(Float.TYPE, new FloatConverter(), throwException, defaultArraySize);
registerArrayConverter(Integer.TYPE, new IntegerConverter(), throwException, defaultArraySize);
registerArrayConverter(Long.TYPE, new LongConverter(), throwException, defaultArraySize);
registerArrayConverter(Short.TYPE, new ShortConverter(), throwException, defaultArraySize);
// Standard
registerArrayConverter(BigDecimal.class, new BigDecimalConverter(), throwException, defaultArraySize);
registerArrayConverter(BigInteger.class, new BigIntegerConverter(), throwException, defaultArraySize);
registerArrayConverter(Boolean.class, new BooleanConverter(), throwException, defaultArraySize);
registerArrayConverter(Byte.class, new ByteConverter(), throwException, defaultArraySize);
registerArrayConverter(Character.class, new CharacterConverter(), throwException, defaultArraySize);
registerArrayConverter(Double.class, new DoubleConverter(), throwException, defaultArraySize);
registerArrayConverter(Float.class, new FloatConverter(), throwException, defaultArraySize);
registerArrayConverter(Integer.class, new IntegerConverter(), throwException, defaultArraySize);
registerArrayConverter(Long.class, new LongConverter(), throwException, defaultArraySize);
registerArrayConverter(Short.class, new ShortConverter(), throwException, defaultArraySize);
registerArrayConverter(String.class, new StringConverter(), throwException, defaultArraySize);
// Other
registerArrayConverter(Class.class, new ClassConverter(), throwException, defaultArraySize);
registerArrayConverter(java.util.Date.class, new DateConverter(), throwException, defaultArraySize);
registerArrayConverter(Calendar.class, new DateConverter(), throwException, defaultArraySize);
registerArrayConverter(File.class, new FileConverter(), throwException, defaultArraySize);
registerArrayConverter(java.sql.Date.class, new SqlDateConverter(), throwException, defaultArraySize);
registerArrayConverter(java.sql.Time.class, new SqlTimeConverter(), throwException, defaultArraySize);
registerArrayConverter(Timestamp.class, new SqlTimestampConverter(), throwException, defaultArraySize);
registerArrayConverter(URL.class, new URLConverter(), throwException, defaultArraySize);
}
/**
* Register a new ArrayConverter with the specified element delegate converter
* that returns a default array of the specified size in the event of conversion errors.
*
* @param componentType The component type of the array
* @param componentConverter The converter to delegate to for the array elements
* @param throwException Whether a conversion exception should be thrown or a default
* value used in the event of a conversion error
* @param defaultArraySize The size of the default array
*/
private void registerArrayConverter(Class componentType, Converter componentConverter,
boolean throwException, int defaultArraySize) {
Class arrayType = Array.newInstance(componentType, 0).getClass();
Converter arrayConverter = null;
if (throwException) {
arrayConverter = new ArrayConverter(arrayType, componentConverter);
} else {
arrayConverter = new ArrayConverter(arrayType, componentConverter, defaultArraySize);
}
register(arrayType, arrayConverter);
}
/** strictly for convenience since it has same parameter order as Map.put */
private void register(Class clazz, Converter converter) {
register(new ConverterFacade(converter), clazz);
}
/**
* Remove any registered {@link Converter} for the specified destination
* Class.
*
* @param clazz Class for which to remove a registered Converter
*/
public void deregister(Class clazz) {
converters.remove(clazz);
}
/**
* Look up and return any registered {@link Converter} for the specified
* destination class; if there is no registered Converter, return
* null.
*
* @param clazz Class for which to return a registered Converter
* @return The registered {@link Converter} or null if not found
*/
public Converter lookup(Class clazz) {
return (converters.get(clazz));
}
/**
* Look up and return any registered {@link Converter} for the specified
* source and destination class; if there is no registered Converter,
* return null.
*
* @param sourceType Class of the value being converted
* @param targetType Class of the value to be converted to
* @return The registered {@link Converter} or null if not found
*/
public Converter lookup(Class sourceType, Class targetType) {
if (targetType == null) {
throw new IllegalArgumentException("Target type is missing");
}
if (sourceType == null) {
return lookup(targetType);
}
Converter converter = null;
// Convert --> String
if (targetType == String.class) {
converter = lookup(sourceType);
if (converter == null && (sourceType.isArray() ||
Collection.class.isAssignableFrom(sourceType))) {
converter = lookup(String[].class);
}
if (converter == null) {
converter = lookup(String.class);
}
return converter;
}
// Convert --> String array
if (targetType == String[].class) {
if (sourceType.isArray() || Collection.class.isAssignableFrom(sourceType)) {
converter = lookup(sourceType);
}
if (converter == null) {
converter = lookup(String[].class);
}
return converter;
}
return lookup(targetType);
}
/**
* Register a custom {@link Converter} for the specified destination
* Class, replacing any previously registered Converter.
*
* @param converter Converter to be registered
* @param clazz Destination class for conversions performed by this
* Converter
*/
public void register(Converter converter, Class clazz) {
converters.put(clazz, converter);
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/ConvertUtilsBean2.java 100644 0 0 5364 12262570611 27370 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
/**
* {@link ConvertUtilsBean} implementation that delegates convert()
* methods to the new {@link ConvertUtilsBean#convert(Object, Class)} method.
*
*
* To configure this implementation for the current context ClassLoader invoke
* BeanUtilsBean.setInstance(new BeanUtilsBean2());
*
*
* @see BeanUtilsBean2
* @version $Id: ConvertUtilsBean2.java 1540186 2013-11-08 21:08:30Z oheger $
* @since 1.8.0
*/
public class ConvertUtilsBean2 extends ConvertUtilsBean {
/**
* Delegates to the new {@link ConvertUtilsBean#convert(Object, Class)}
* method.
*
* @param value Value to be converted (may be null)
* @return The converted String value or null if value is null
*
* @see ConvertUtilsBean#convert(String[], Class)
*/
@Override
public String convert(Object value) {
return (String)convert(value, String.class);
}
/**
* Delegates to the new {@link ConvertUtilsBean#convert(Object, Class)}
* method.
*
* @param value Value to be converted (may be null)
* @param clazz Java class to be converted to (must not be null)
* @return The converted value or null if value is null
*
* @see ConvertUtilsBean#convert(String[], Class)
*/
@Override
public Object convert(String value, Class clazz) {
return convert((Object)value, clazz);
}
/**
* Delegates to the new {@link ConvertUtilsBean#convert(Object, Class)}
* method.
*
* @param value Array of values to be converted
* @param clazz Java array or element class to be converted to (must not be null)
* @return The converted value
*
* @see ConvertUtilsBean#convert(String[], Class)
*/
@Override
public Object convert(String[] value, Class clazz) {
return convert((Object)value, clazz);
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/DefaultBeanIntrospector.java 100644 0 0 17201 12262570612 30657 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
import java.beans.BeanInfo;
import java.beans.IndexedPropertyDescriptor;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
*
* The default {@link BeanIntrospector} implementation.
*
*
* This class implements a default bean introspection algorithm based on the JDK
* classes in the java.beans package. It discovers properties
* conforming to the Java Beans specification.
*
*
* This class is a singleton. The single instance can be obtained using the
* {@code INSTANCE} field. It does not define any state and thus can be
* shared by arbitrary clients. {@link PropertyUtils} per default uses this
* instance as its only {@code BeanIntrospector} object.
*
*
* @version $Id: DefaultBeanIntrospector.java 1540359 2013-11-09 18:10:52Z oheger $
* @since 1.9
*/
public class DefaultBeanIntrospector implements BeanIntrospector {
/** The singleton instance of this class. */
public static final BeanIntrospector INSTANCE = new DefaultBeanIntrospector();
/** Constant for argument types of a method that expects no arguments. */
private static final Class[] EMPTY_CLASS_PARAMETERS = new Class[0];
/** Constant for arguments types of a method that expects a list argument. */
private static final Class[] LIST_CLASS_PARAMETER = new Class[] { java.util.List.class };
/** Log instance */
private final Log log = LogFactory.getLog(getClass());
/**
* Private constructor so that no instances can be created.
*/
private DefaultBeanIntrospector() {
}
/**
* Performs introspection of a specific Java class. This implementation uses
* the {@code java.beans.Introspector.getBeanInfo()} method to obtain
* all property descriptors for the current class and adds them to the
* passed in introspection context.
*
* @param icontext the introspection context
*/
public void introspect(IntrospectionContext icontext) {
BeanInfo beanInfo = null;
try {
beanInfo = Introspector.getBeanInfo(icontext.getTargetClass());
} catch (IntrospectionException e) {
// no descriptors are added to the context
log.error(
"Error when inspecting class " + icontext.getTargetClass(),
e);
return;
}
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
if (descriptors == null) {
descriptors = new PropertyDescriptor[0];
}
handleIndexedPropertyDescriptors(icontext.getTargetClass(),
descriptors);
icontext.addPropertyDescriptors(descriptors);
}
/**
* This method fixes an issue where IndexedPropertyDescriptor behaves
* differently in different versions of the JDK for 'indexed' properties
* which use java.util.List (rather than an array). It implements a
* workaround for Bug 28358. If you have a Bean with the following
* getters/setters for an indexed property:
*
*
* public List getFoo()
* public Object getFoo(int index)
* public void setFoo(List foo)
* public void setFoo(int index, Object foo)
*
*
* then the IndexedPropertyDescriptor's getReadMethod() and getWriteMethod()
* behave as follows:
*
* JDK 1.3.1_04: returns valid Method objects from these methods.
* JDK 1.4.2_05: returns null from these methods.
*
*
* @param beanClass the current class to be inspected
* @param descriptors the array with property descriptors
*/
private void handleIndexedPropertyDescriptors(Class beanClass,
PropertyDescriptor[] descriptors) {
for (PropertyDescriptor pd : descriptors) {
if (pd instanceof IndexedPropertyDescriptor) {
IndexedPropertyDescriptor descriptor = (IndexedPropertyDescriptor) pd;
String propName = descriptor.getName().substring(0, 1)
.toUpperCase()
+ descriptor.getName().substring(1);
if (descriptor.getReadMethod() == null) {
String methodName = descriptor.getIndexedReadMethod() != null ? descriptor
.getIndexedReadMethod().getName() : "get"
+ propName;
Method readMethod = MethodUtils
.getMatchingAccessibleMethod(beanClass, methodName,
EMPTY_CLASS_PARAMETERS);
if (readMethod != null) {
try {
descriptor.setReadMethod(readMethod);
} catch (Exception e) {
log.error(
"Error setting indexed property read method",
e);
}
}
}
if (descriptor.getWriteMethod() == null) {
String methodName = descriptor.getIndexedWriteMethod() != null ? descriptor
.getIndexedWriteMethod().getName() : "set"
+ propName;
Method writeMethod = MethodUtils
.getMatchingAccessibleMethod(beanClass, methodName,
LIST_CLASS_PARAMETER);
if (writeMethod == null) {
for (Method m : beanClass.getMethods()) {
if (m.getName().equals(methodName)) {
Class[] parameterTypes = m.getParameterTypes();
if (parameterTypes.length == 1
&& List.class
.isAssignableFrom(parameterTypes[0])) {
writeMethod = m;
break;
}
}
}
}
if (writeMethod != null) {
try {
descriptor.setWriteMethod(writeMethod);
} catch (Exception e) {
log.error(
"Error setting indexed property write method",
e);
}
}
}
}
}
}
}
././@LongLink 100644 0 0 150 12262571655 10262 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/DefaultIntrospectionContext.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/DefaultIntrospectionContext.j100644 0 0 7254 12262570612 31102 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
import java.beans.PropertyDescriptor;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
*
* An implementation of the {@code IntrospectionContext} interface used by
* {@link PropertyUtilsBean} when doing introspection of a bean class.
*
*
* This class implements the methods required by the
* {@code IntrospectionContext} interface in a straight-forward manner
* based on a map. It is used internally only. It is not thread-safe.
*
*
* @version $Id: DefaultIntrospectionContext.java 1540359 2013-11-09 18:10:52Z oheger $
* @since 1.9
*/
class DefaultIntrospectionContext implements IntrospectionContext {
/** Constant for an empty array of property descriptors. */
private static final PropertyDescriptor[] EMPTY_DESCRIPTORS = new PropertyDescriptor[0];
/** The current class for introspection. */
private final Class currentClass;
/** A map for storing the already added property descriptors. */
private final Map descriptors;
/**
*
* Creates a new instance of DefaultIntrospectionContext and sets
* the current class for introspection.
*
* @param cls the current class
*/
public DefaultIntrospectionContext(Class cls) {
currentClass = cls;
descriptors = new HashMap();
}
public Class getTargetClass() {
return currentClass;
}
public void addPropertyDescriptor(PropertyDescriptor desc) {
if (desc == null) {
throw new IllegalArgumentException(
"Property descriptor must not be null!");
}
descriptors.put(desc.getName(), desc);
}
public void addPropertyDescriptors(PropertyDescriptor[] descs) {
if (descs == null) {
throw new IllegalArgumentException(
"Array with descriptors must not be null!");
}
for (int i = 0; i < descs.length; i++) {
addPropertyDescriptor(descs[i]);
}
}
public boolean hasProperty(String name) {
return descriptors.containsKey(name);
}
public PropertyDescriptor getPropertyDescriptor(String name) {
return descriptors.get(name);
}
public void removePropertyDescriptor(String name) {
descriptors.remove(name);
}
public Set propertyNames() {
return descriptors.keySet();
}
/**
* Returns an array with all descriptors added to this context. This method
* is used to obtain the results of introspection.
*
* @return an array with all known property descriptors
*/
public PropertyDescriptor[] getPropertyDescriptors() {
return descriptors.values().toArray(EMPTY_DESCRIPTORS);
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/DynaBean.java 100644 0 0 14333 12262570612 25555 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
/**
* A DynaBean is a Java object that supports properties
* whose names and data types, as well as values, may be dynamically modified.
* To the maximum degree feasible, other components of the BeanUtils package
* will recognize such beans and treat them as standard JavaBeans for the
* purpose of retrieving and setting property values.
*
* @version $Id: DynaBean.java 1454597 2013-03-08 21:58:12Z britter $
*/
public interface DynaBean {
/**
* Does the specified mapped property contain a value for the specified
* key value?
*
* @param name Name of the property to check
* @param key Name of the key to check
* @return true if the mapped property contains a value for
* the specified key, otherwise false
*
* @exception IllegalArgumentException if there is no property
* of the specified name
*/
public boolean contains(String name, String key);
/**
* Return the value of a simple property with the specified name.
*
* @param name Name of the property whose value is to be retrieved
* @return The property's value
*
* @exception IllegalArgumentException if there is no property
* of the specified name
*/
public Object get(String name);
/**
* Return the value of an indexed property with the specified name.
*
* @param name Name of the property whose value is to be retrieved
* @param index Index of the value to be retrieved
* @return The indexed property's value
*
* @exception IllegalArgumentException if there is no property
* of the specified name
* @exception IllegalArgumentException if the specified property
* exists, but is not indexed
* @exception IndexOutOfBoundsException if the specified index
* is outside the range of the underlying property
* @exception NullPointerException if no array or List has been
* initialized for this property
*/
public Object get(String name, int index);
/**
* Return the value of a mapped property with the specified name,
* or null if there is no value for the specified key.
*
* @param name Name of the property whose value is to be retrieved
* @param key Key of the value to be retrieved
* @return The mapped property's value
*
* @exception IllegalArgumentException if there is no property
* of the specified name
* @exception IllegalArgumentException if the specified property
* exists, but is not mapped
*/
public Object get(String name, String key);
/**
* Return the DynaClass instance that describes the set of
* properties available for this DynaBean.
*
* @return The associated DynaClass
*/
public DynaClass getDynaClass();
/**
* Remove any existing value for the specified key on the
* specified mapped property.
*
* @param name Name of the property for which a value is to
* be removed
* @param key Key of the value to be removed
*
* @exception IllegalArgumentException if there is no property
* of the specified name
*/
public void remove(String name, String key);
/**
* 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
*
* @exception ConversionException if the specified value cannot be
* converted to the type required for this property
* @exception IllegalArgumentException if there is no property
* of the specified name
* @exception NullPointerException if an attempt is made to set a
* primitive property to null
*/
public void set(String name, Object value);
/**
* Set the value of an indexed property with the specified name.
*
* @param name Name of the property whose value is to be set
* @param index Index of the property to be set
* @param value Value to which this property is to be set
*
* @exception ConversionException if the specified value cannot be
* converted to the type required for this property
* @exception IllegalArgumentException if there is no property
* of the specified name
* @exception IllegalArgumentException if the specified property
* exists, but is not indexed
* @exception IndexOutOfBoundsException if the specified index
* is outside the range of the underlying property
*/
public void set(String name, int index, Object value);
/**
* Set the value of a mapped property with the specified name.
*
* @param name Name of the property whose value is to be set
* @param key Key of the property to be set
* @param value Value to which this property is to be set
*
* @exception ConversionException if the specified value cannot be
* converted to the type required for this property
* @exception IllegalArgumentException if there is no property
* of the specified name
* @exception IllegalArgumentException if the specified property
* exists, but is not mapped
*/
public void set(String name, String key, Object value);
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/DynaBeanMapDecorator.java 100644 0 0 10261 12262570612 30052 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
/**
* Decorates a {@link DynaBean} to provide Map behaviour.
*
* The motivation for this implementation is to provide access to {@link DynaBean}
* properties in technologies that are unaware of BeanUtils and {@link DynaBean}s -
* such as the expression languages of JSTL and JSF.
*
* This can be achieved either by wrapping the {@link DynaBean} prior to
* providing it to the technolody to process or by providing a Map
* accessor method on the DynaBean implementation:
*
* public Map getMap() {
* return new DynaBeanMapDecorator(this);
* }
*
* This, for example, could be used in JSTL in the following way to access
* a DynaBean's fooProperty:
*
${myDynaBean.map .fooProperty}
*
* Usage
*
* To decorate a {@link DynaBean} simply instantiate this class with the
* target {@link DynaBean}:
*
* Map fooMap = new DynaBeanMapDecorator(fooDynaBean);The above example creates a read only Map.
* To create a Map which can be modified, construct a
* DynaBeanMapDecorator with the read only false:
*
* Map fooMap = new DynaBeanMapDecorator(fooDynaBean, false);Limitations
* In this implementation the entrySet(), keySet()
* and values() methods create an unmodifiable Set and it does not support the Map's clear()
* and remove() operations.
* For reasons of backwards compatibility, the generic types of this
* {@code Map} implementation are {@code }. However, the
* keys of the map are typically strings.
*
* @since BeanUtils 1.8.0
* @version $Id: DynaBeanMapDecorator.java 1540186 2013-11-08 21:08:30Z oheger $
* @deprecated Use {@link DynaBeanPropertyMapDecorator} instead. When adding
* generics it turned out that it was not possible to use the correct type
* parameters without breaking backwards compatibility. Therefore, class
* {@code DynaBeanPropertyMapDecorator} was introduced as a replacement.
*/
@Deprecated
public class DynaBeanMapDecorator extends BaseDynaBeanMapDecorator {
/**
* Construct a Map for the specified {@link DynaBean}.
*
* @param dynaBean The dyna bean being decorated
* @param readOnly true if the Map is read only
* otherwise false
* @throws IllegalArgumentException if the {@link DynaBean} is null.
*/
public DynaBeanMapDecorator(DynaBean dynaBean, boolean readOnly) {
super(dynaBean, readOnly);
}
/**
* Constructs a read only Map for the specified
* {@link DynaBean}.
*
* @param dynaBean The dyna bean being decorated
* @throws IllegalArgumentException if the {@link DynaBean} is null.
*/
public DynaBeanMapDecorator(DynaBean dynaBean) {
super(dynaBean);
}
@Override
protected Object convertKey(String propertyName) {
return propertyName;
}
}
././@LongLink 100644 0 0 151 12262571655 10263 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/DynaBeanPropertyMapDecorator.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/DynaBeanPropertyMapDecorator.100644 0 0 7463 12262570612 30747 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
/**
* Decorates a {@link DynaBean} to provide Map behavior.
*
* The motivation for this implementation is to provide access to {@link DynaBean}
* properties in technologies that are unaware of BeanUtils and {@link DynaBean}s -
* such as the expression languages of JSTL and JSF.
*
* This can be achieved either by wrapping the {@link DynaBean} prior to
* providing it to the technology to process or by providing a Map
* accessor method on the DynaBean implementation:
*
* public Map<String, Object> getMap() {
* return new DynaBeanPropertyMapDecorator(this);
* }
*
* This, for example, could be used in JSTL in the following way to access
* a DynaBean's fooProperty:
*
${myDynaBean.map .fooProperty}
*
* Usage
*
* To decorate a {@link DynaBean} simply instantiate this class with the
* target {@link DynaBean}:
*
* Map<String, Object> fooMap = new DynaBeanPropertyMapDecorator(fooDynaBean);The above example creates a read only Map.
* To create a Map which can be modified, construct a
* DynaBeanPropertyMapDecorator with the read only false:
*
* Map<String, Object> fooMap =
* new DynaBeanPropertyMapDecorator(fooDynaBean, false);Limitations
* In this implementation the entrySet(), keySet()
* and values() methods create an unmodifiable Set and it does not support the Map's clear()
* and remove() operations.
*
* @since BeanUtils 1.9.0
* @version $Id: DynaBeanPropertyMapDecorator.java 1540518 2013-11-10 19:04:04Z oheger $
*/
public class DynaBeanPropertyMapDecorator extends BaseDynaBeanMapDecorator {
/**
* Construct a Map for the specified {@link DynaBean}.
*
* @param dynaBean The dyna bean being decorated
* @param readOnly true if the Map is read only
* otherwise false
* @throws IllegalArgumentException if the {@link DynaBean} is null.
*/
public DynaBeanPropertyMapDecorator(DynaBean dynaBean, boolean readOnly) {
super(dynaBean, readOnly);
}
/**
* Constructs a read only Map for the specified
* {@link DynaBean}.
*
* @param dynaBean The dyna bean being decorated
* @throws IllegalArgumentException if the {@link DynaBean} is null.
*/
public DynaBeanPropertyMapDecorator(DynaBean dynaBean) {
super(dynaBean);
}
@Override
protected String convertKey(String propertyName) {
return propertyName;
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/DynaClass.java 100644 0 0 6366 12262570612 25744 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
/**
* A DynaClass is a simulation of the functionality of
* java.lang.Class for classes implementing the
* DynaBean interface. DynaBean instances that share the same
* DynaClass all have the same set of available properties, along with any
* associated data types, read-only states, and write-only states.
*
* @version $Id: DynaClass.java 1454597 2013-03-08 21:58:12Z britter $
*/
public interface DynaClass {
/**
* Return the name of this DynaClass (analogous to the
* getName() method of java.lang.ClassDynaClass implementation class to support
* different dynamic classes, with different sets of properties.
*
* @return the name of the DynaClass
*/
public String getName();
/**
* Return a property descriptor for the specified property, if it exists;
* otherwise, return null.
*
* @param name Name of the dynamic property for which a descriptor
* is requested
* @return The descriptor for the specified property
*
* @exception IllegalArgumentException if no property name is specified
*/
public DynaProperty getDynaProperty(String name);
/**
* 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
*/
public DynaProperty[] getDynaProperties();
/**
* Instantiate and return a new DynaBean instance, associated
* with this DynaClass.
*
* @return A new DynaBean instance
*
* @exception IllegalAccessException if the Class or the appropriate
* constructor is not accessible
* @exception InstantiationException if this Class represents an abstract
* class, an array class, a primitive type, or void; or if instantiation
* fails for some other reason
*/
public DynaBean newInstance()
throws IllegalAccessException, InstantiationException;
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/DynaProperty.java 100644 0 0 30376 12262570612 26541 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.StreamCorruptedException;
import java.util.List;
import java.util.Map;
/**
* The metadata describing an individual property of a DynaBean.
*
* The meta contains an optional content type property ({@link #getContentType})
* for use by mapped and iterated properties.
* A mapped or iterated property may choose to indicate the type it expects.
* The DynaBean implementation may choose to enforce this type on its entries.
* Alternatively, an implementatin may choose to ignore this property.
* All keys for maps must be of type String so no meta data is needed for map keys.
*
* @version $Id: DynaProperty.java 1546738 2013-11-30 16:24:19Z oheger $
*/
public class DynaProperty implements Serializable {
// ----------------------------------------------------------- Constants
/*
* There are issues with serializing primitive class types on certain JVM versions
* (including java 1.3).
* This class uses a custom serialization implementation that writes an integer
* for these primitive class.
* This list of constants are the ones used in serialization.
* If these values are changed, then older versions will no longer be read correctly
*/
private static final int BOOLEAN_TYPE = 1;
private static final int BYTE_TYPE = 2;
private static final int CHAR_TYPE = 3;
private static final int DOUBLE_TYPE = 4;
private static final int FLOAT_TYPE = 5;
private static final int INT_TYPE = 6;
private static final int LONG_TYPE = 7;
private static final int SHORT_TYPE = 8;
// ----------------------------------------------------------- Constructors
/**
* Construct a property that accepts any data type.
*
* @param name Name of the property being described
*/
public DynaProperty(String name) {
this(name, Object.class);
}
/**
* Construct a property of the specified data type.
*
* @param name Name of the property being described
* @param type Java class representing the property data type
*/
public DynaProperty(String name, Class type) {
super();
this.name = name;
this.type = type;
if (type != null && type.isArray()) {
this.contentType = type.getComponentType();
}
}
/**
* Construct an indexed or mapped DynaProperty that supports (pseudo)-introspection
* of the content type.
*
* @param name Name of the property being described
* @param type Java class representing the property data type
* @param contentType Class that all indexed or mapped elements are instances of
*/
public DynaProperty(String name, Class type, Class contentType) {
super();
this.name = name;
this.type = type;
this.contentType = contentType;
}
// ------------------------------------------------------------- Properties
/** Property name */
protected String name = null;
/**
* Get the name of this property.
* @return the name of the property
*/
public String getName() {
return (this.name);
}
/** Property type */
protected transient Class type = null;
/**
* Gets the Java class representing the data type of the underlying property
* values.
*
* There are issues with serializing primitive class types on certain JVM versions
* (including java 1.3).
* Therefore, this field must not be serialized using the standard methods .
*
* Please leave this field as transient
*
* @return the property type
*/
public Class getType() {
return (this.type);
}
/** The (optional) type of content elements for indexed DynaProperty */
protected transient Class contentType;
/**
* Gets the (optional) type of the indexed content for DynaProperty's
* that support this feature.
*
* There are issues with serializing primitive class types on certain JVM versions
* (including java 1.3).
* Therefore, this field must not be serialized using the standard methods .
*
* @return the Class for the content type if this is an indexed DynaProperty
* and this feature is supported. Otherwise null.
*/
public Class getContentType() {
return contentType;
}
// --------------------------------------------------------- Public Methods
/**
* Does this property represent an indexed value (ie an array or List)?
*
* @return true if the property is indexed (i.e. is a List or
* array), otherwise false
*/
public boolean isIndexed() {
if (type == null) {
return (false);
} else if (type.isArray()) {
return (true);
} else if (List.class.isAssignableFrom(type)) {
return (true);
} else {
return (false);
}
}
/**
* Does this property represent a mapped value (ie a Map)?
*
* @return true if the property is a Map
* otherwise false
*/
public boolean isMapped() {
if (type == null) {
return (false);
} else {
return (Map.class.isAssignableFrom(type));
}
}
/**
* Checks this instance against the specified Object for equality. Overrides the
* default refererence test for equality provided by {@link java.lang.Object#equals(Object)}
* @param obj The object to compare to
* @return true if object is a dyna property with the same name
* type and content type, otherwise false
* @since 1.8.0
*/
@Override
public boolean equals(final Object obj) {
boolean result = false;
result = (obj == this);
if ((!result) && obj instanceof DynaProperty) {
final DynaProperty that = (DynaProperty) obj;
result =
((this.name == null) ? (that.name == null) : (this.name.equals(that.name))) &&
((this.type == null) ? (that.type == null) : (this.type.equals(that.type))) &&
((this.contentType == null) ? (that.contentType == null) : (this.contentType.equals(that.contentType)));
}
return result;
}
/**
* @return the hashcode for this dyna property
* @see java.lang.Object#hashCode
* @since 1.8.0
*/
@Override
public int hashCode() {
int result = 1;
result = result * 31 + ((name == null) ? 0 : name.hashCode());
result = result * 31 + ((type == null) ? 0 : type.hashCode());
result = result * 31 + ((contentType == null) ? 0 : contentType.hashCode());
return result;
}
/**
* Return a String representation of this Object.
* @return a String representation of the dyna property
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder("DynaProperty[name=");
sb.append(this.name);
sb.append(",type=");
sb.append(this.type);
if (isMapped() || isIndexed()) {
sb.append(" <").append(this.contentType).append(">");
}
sb.append("]");
return (sb.toString());
}
// --------------------------------------------------------- Serialization helper methods
/**
* Writes this object safely.
* There are issues with serializing primitive class types on certain JVM versions
* (including java 1.3).
* This method provides a workaround.
*/
private void writeObject(ObjectOutputStream out) throws IOException {
writeAnyClass(this.type,out);
if (isMapped() || isIndexed()) {
writeAnyClass(this.contentType,out);
}
// write out other values
out.defaultWriteObject();
}
/**
* Write a class using safe encoding to workaround java 1.3 serialization bug.
*/
private void writeAnyClass(Class clazz, ObjectOutputStream out) throws IOException {
// safely write out any class
int primitiveType = 0;
if (Boolean.TYPE.equals(clazz)) {
primitiveType = BOOLEAN_TYPE;
} else if (Byte.TYPE.equals(clazz)) {
primitiveType = BYTE_TYPE;
} else if (Character.TYPE.equals(clazz)) {
primitiveType = CHAR_TYPE;
} else if (Double.TYPE.equals(clazz)) {
primitiveType = DOUBLE_TYPE;
} else if (Float.TYPE.equals(clazz)) {
primitiveType = FLOAT_TYPE;
} else if (Integer.TYPE.equals(clazz)) {
primitiveType = INT_TYPE;
} else if (Long.TYPE.equals(clazz)) {
primitiveType = LONG_TYPE;
} else if (Short.TYPE.equals(clazz)) {
primitiveType = SHORT_TYPE;
}
if (primitiveType == 0) {
// then it's not a primitive type
out.writeBoolean(false);
out.writeObject(clazz);
} else {
// we'll write out a constant instead
out.writeBoolean(true);
out.writeInt(primitiveType);
}
}
/**
* Reads field values for this object safely.
* There are issues with serializing primitive class types on certain JVM versions
* (including java 1.3).
* This method provides a workaround.
*
* @throws StreamCorruptedException when the stream data values are outside expected range
*/
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
this.type = readAnyClass(in);
if (isMapped() || isIndexed()) {
this.contentType = readAnyClass(in);
}
// read other values
in.defaultReadObject();
}
/**
* Reads a class using safe encoding to workaround java 1.3 serialization bug.
*/
private Class readAnyClass(ObjectInputStream in) throws IOException, ClassNotFoundException {
// read back type class safely
if (in.readBoolean()) {
// it's a type constant
switch (in.readInt()) {
case BOOLEAN_TYPE: return Boolean.TYPE;
case BYTE_TYPE: return Byte.TYPE;
case CHAR_TYPE: return Character.TYPE;
case DOUBLE_TYPE: return Double.TYPE;
case FLOAT_TYPE: return Float.TYPE;
case INT_TYPE: return Integer.TYPE;
case LONG_TYPE: return Long.TYPE;
case SHORT_TYPE: return Short.TYPE;
default:
// something's gone wrong
throw new StreamCorruptedException(
"Invalid primitive type. "
+ "Check version of beanutils used to serialize is compatible.");
}
} else {
// it's another class
return ((Class) in.readObject());
}
}
} ././@LongLink 100644 0 0 147 12262571655 10270 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/expression/DefaultResolver.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/expression/DefaultResolver.ja100644 0 0 24362 12262570611 31054 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.expression;
/**
* Default Property Name Expression {@link Resolver} Implementation.
*
* This class assists in resolving property names in the following five formats,
* with the layout of an identifying String in parentheses:
*
* Simple (name) - The specified
* name identifies an individual property of a particular
* JavaBean. The name of the actual getter or setter method to be used
* is determined using standard JavaBeans instrospection, so that (unless
* overridden by a BeanInfo class, a property named "xyz"
* will have a getter method named getXyz() or (for boolean
* properties only) isXyz(), and a setter method named
* setXyz().Nested (name1.name2.name3) The first
* name element is used to select a property getter, as for simple
* references above. The object returned for this property is then
* consulted, using the same approach, for a property getter for a
* property named name2, and so on. The property value that
* is ultimately retrieved or modified is the one identified by the
* last name element.Indexed (name[index]) - The underlying
* property value is assumed to be an array, or this JavaBean is assumed
* to have indexed property getter and setter methods. The appropriate
* (zero-relative) entry in the array is selected. List
* objects are now also supported for read/write. You simply need to define
* a getter that returns the ListMapped (name(key)) - The JavaBean
* is assumed to have an property getter and setter methods with an
* additional attribute of type java.lang.String.Combined (name1.name2[index].name3(key)) -
* Combining mapped, nested, and indexed references is also
* supported.
*
* @version $Id: DefaultResolver.java 1454597 2013-03-08 21:58:12Z britter $
* @since 1.8.0
*/
public class DefaultResolver implements Resolver {
private static final char NESTED = '.';
private static final char MAPPED_START = '(';
private static final char MAPPED_END = ')';
private static final char INDEXED_START = '[';
private static final char INDEXED_END = ']';
/**
* Default Constructor.
*/
public DefaultResolver() {
}
/**
* Return the index value from the property expression or -1.
*
* @param expression The property expression
* @return The index value or -1 if the property is not indexed
* @throws IllegalArgumentException If the indexed property is illegally
* formed or has an invalid (non-numeric) value.
*/
public int getIndex(String expression) {
if (expression == null || expression.length() == 0) {
return -1;
}
for (int i = 0; i < expression.length(); i++) {
char c = expression.charAt(i);
if (c == NESTED || c == MAPPED_START) {
return -1;
} else if (c == INDEXED_START) {
int end = expression.indexOf(INDEXED_END, i);
if (end < 0) {
throw new IllegalArgumentException("Missing End Delimiter");
}
String value = expression.substring(i + 1, end);
if (value.length() == 0) {
throw new IllegalArgumentException("No Index Value");
}
int index = 0;
try {
index = Integer.parseInt(value, 10);
} catch (Exception e) {
throw new IllegalArgumentException("Invalid index value '"
+ value + "'");
}
return index;
}
}
return -1;
}
/**
* Return the map key from the property expression or null.
*
* @param expression The property expression
* @return The index value
* @throws IllegalArgumentException If the mapped property is illegally formed.
*/
public String getKey(String expression) {
if (expression == null || expression.length() == 0) {
return null;
}
for (int i = 0; i < expression.length(); i++) {
char c = expression.charAt(i);
if (c == NESTED || c == INDEXED_START) {
return null;
} else if (c == MAPPED_START) {
int end = expression.indexOf(MAPPED_END, i);
if (end < 0) {
throw new IllegalArgumentException("Missing End Delimiter");
}
return expression.substring(i + 1, end);
}
}
return null;
}
/**
* Return the property name from the property expression.
*
* @param expression The property expression
* @return The property name
*/
public String getProperty(String expression) {
if (expression == null || expression.length() == 0) {
return expression;
}
for (int i = 0; i < expression.length(); i++) {
char c = expression.charAt(i);
if (c == NESTED) {
return expression.substring(0, i);
} else if (c == MAPPED_START || c == INDEXED_START) {
return expression.substring(0, i);
}
}
return expression;
}
/**
* Indicates whether or not the expression
* contains nested property expressions or not.
*
* @param expression The property expression
* @return The next property expression
*/
public boolean hasNested(String expression) {
if (expression == null || expression.length() == 0) {
return false;
} else {
return (remove(expression) != null);
}
}
/**
* Indicate whether the expression is for an indexed property or not.
*
* @param expression The property expression
* @return true if the expresion is indexed,
* otherwise false
*/
public boolean isIndexed(String expression) {
if (expression == null || expression.length() == 0) {
return false;
}
for (int i = 0; i < expression.length(); i++) {
char c = expression.charAt(i);
if (c == NESTED || c == MAPPED_START) {
return false;
} else if (c == INDEXED_START) {
return true;
}
}
return false;
}
/**
* Indicate whether the expression is for a mapped property or not.
*
* @param expression The property expression
* @return true if the expresion is mapped,
* otherwise false
*/
public boolean isMapped(String expression) {
if (expression == null || expression.length() == 0) {
return false;
}
for (int i = 0; i < expression.length(); i++) {
char c = expression.charAt(i);
if (c == NESTED || c == INDEXED_START) {
return false;
} else if (c == MAPPED_START) {
return true;
}
}
return false;
}
/**
* Extract the next property expression from the
* current expression.
*
* @param expression The property expression
* @return The next property expression
*/
public String next(String expression) {
if (expression == null || expression.length() == 0) {
return null;
}
boolean indexed = false;
boolean mapped = false;
for (int i = 0; i < expression.length(); i++) {
char c = expression.charAt(i);
if (indexed) {
if (c == INDEXED_END) {
return expression.substring(0, i + 1);
}
} else if (mapped) {
if (c == MAPPED_END) {
return expression.substring(0, i + 1);
}
} else {
if (c == NESTED) {
return expression.substring(0, i);
} else if (c == MAPPED_START) {
mapped = true;
} else if (c == INDEXED_START) {
indexed = true;
}
}
}
return expression;
}
/**
* Remove the last property expresson from the
* current expression.
*
* @param expression The property expression
* @return The new expression value, with first property
* expression removed - null if there are no more expressions
*/
public String remove(String expression) {
if (expression == null || expression.length() == 0) {
return null;
}
String property = next(expression);
if (expression.length() == property.length()) {
return null;
}
int start = property.length();
if (expression.charAt(start) == NESTED) {
start++;
}
return expression.substring(start);
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/expression/package-info.java 100644 0 0 1662 12262570611 30577 0 ustar 0 0 /*
* 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.
*/
/**
* Contains the {@link Resolver} interface and implementations.
*/
package org.apache.commons.beanutils.expression;
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/expression/Resolver.java 100644 0 0 14641 12262570611 30075 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils.expression;
/**
* Property Name Expression Resolver.
*
* Methods such as PropertyUtilsBean's setNestedProperty() method
* use a Resolver to process a property name
* expression and resolve nested , indexed and mapped
* property names. The following code provides an example usage
* demonstrating all the methods:
*
*
* // Iterate through a nested property expression
* while (resolver.hasNested(name)) {
*
* // isolate a single property from a nested expresion
* String next = resolver.next(name);
*
* // Process...
* String property = resolver.getProperty(next);
* if (resolver.isIndexed(next)) {
*
* int index = resolver.getIndex(next);
* bean = getIndexedProperty(bean, property, index);
*
* } else if (resolver.isMapped(next)) {
*
* String key = resolver.getKey(next);
* bean = getMappedProperty(bean, property, key);
*
* } else {
*
* bean = getSimpleProperty(bean, property);
*
* }
*
* // remove the processed property from the expression
* name = resolver.remove(name);
* }
*
*
* In order to create an implementation, it is important to understand how
* BeanUtils/PropertyUtils uses the resolver. The following are
* the main methods that use it:
*
* {@link org.apache.commons.beanutils.PropertyUtilsBean}
*
* {@link org.apache.commons.beanutils.PropertyUtilsBean#getIndexedProperty(Object, String)}
* {@link org.apache.commons.beanutils.PropertyUtilsBean#getMappedProperty(Object, String)}
* {@link org.apache.commons.beanutils.PropertyUtilsBean#getNestedProperty(Object, String)}
* {@link org.apache.commons.beanutils.PropertyUtilsBean#getPropertyDescriptor(Object, String)}
* {@link org.apache.commons.beanutils.PropertyUtilsBean#getSimpleProperty(Object, String)}
* {@link org.apache.commons.beanutils.PropertyUtilsBean#setIndexedProperty(Object, String, Object)}
* {@link org.apache.commons.beanutils.PropertyUtilsBean#setMappedProperty(Object, String, Object)}
* {@link org.apache.commons.beanutils.PropertyUtilsBean#setNestedProperty(Object, String, Object)}
* {@link org.apache.commons.beanutils.PropertyUtilsBean#setSimpleProperty(Object, String, Object)}
*
* {@link org.apache.commons.beanutils.BeanUtilsBean}
*
* {@link org.apache.commons.beanutils.BeanUtilsBean#copyProperty(Object, String, Object)}
* {@link org.apache.commons.beanutils.BeanUtilsBean#setProperty(Object, String, Object)}
*
* {@link org.apache.commons.beanutils.locale.LocaleBeanUtilsBean}
*
* {@link org.apache.commons.beanutils.locale.LocaleBeanUtilsBean#setProperty(Object,
* String, Object, String)}
*
*
*
* @version $Id: Resolver.java 1454597 2013-03-08 21:58:12Z britter $
* @see org.apache.commons.beanutils.PropertyUtilsBean#setResolver(Resolver)
* @since 1.8.0
*/
public interface Resolver {
/**
* Extract the index value from the property expression or -1.
*
* @param expression The property expression
* @return The index value or -1 if the property is not indexed
* @throws IllegalArgumentException If the indexed property is illegally
* formed or has an invalid (non-numeric) value
*/
int getIndex(String expression);
/**
* Extract the map key from the property expression or null.
*
* @param expression The property expression
* @return The index value
* @throws IllegalArgumentException If the mapped property is illegally formed
*/
String getKey(String expression);
/**
* Return the property name from the property expression.
*
* @param expression The property expression
* @return The property name
*/
String getProperty(String expression);
/**
* Indicates whether or not the expression
* contains nested property expressions or not.
*
* @param expression The property expression
* @return The next property expression
*/
boolean hasNested(String expression);
/**
* Indicate whether the expression is for an indexed property or not.
*
* @param expression The property expression
* @return true if the expresion is indexed,
* otherwise false
*/
boolean isIndexed(String expression);
/**
* Indicate whether the expression is for a mapped property or not.
*
* @param expression The property expression
* @return true if the expresion is mapped,
* otherwise false
*/
boolean isMapped(String expression);
/**
* Extract the next property expression from the
* current expression.
*
* @param expression The property expression
* @return The next property expression
*/
String next(String expression);
/**
* Remove the last property expresson from the
* current expression.
*
* @param expression The property expression
* @return The new expression value, with first property
* expression removed - null if there are no more expressions
*/
String remove(String expression);
}
././@LongLink 100644 0 0 153 12262571655 10265 L ustar 0 0 commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/FluentPropertyBeanIntrospector.java commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/FluentPropertyBeanIntrospecto100644 0 0 15507 12262570612 31202 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.Locale;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
*
* An implementation of the BeanIntrospector interface which can
* detect write methods for properties used in fluent API scenario.
*
*
* A fluent API allows setting multiple properties using a single
* statement by supporting so-called method chaining : Methods for
* setting a property value do not return void , but an object which can
* be called for setting another property. An example of such a fluent API could
* look as follows:
*
*
* public class FooBuilder {
* public FooBuilder setFooProperty1(String value) {
* ...
* return this;
* }
*
* public FooBuilder setFooProperty2(int value) {
* ...
* return this;
* }
* }
*
*
* Per default, PropertyUtils does not detect methods like this
* because, having a non-void return type, they violate the Java Beans
* specification.
*
*
* This class is more tolerant with regards to the return type of a set method.
* It basically iterates over all methods of a class and filters them for a
* configurable prefix (the default prefix is set). It then
* generates corresponding PropertyDescriptor objects for the
* methods found which use these methods as write methods.
*
*
* An instance of this class is intended to collaborate with a
* {@link DefaultBeanIntrospector} object. So best results are achieved by
* adding this instance as custom {@code BeanIntrospector} after the
* DefaultBeanIntrospector object. Then default introspection finds
* read-only properties because it does not detect the write methods with a
* non-void return type. {@code FluentPropertyBeanIntrospector}
* completes the descriptors for these properties by setting the correct write
* method.
*
*
* @version $Id: FluentPropertyBeanIntrospector.java 1540359 2013-11-09 18:10:52Z oheger $
* @since 1.9
*/
public class FluentPropertyBeanIntrospector implements BeanIntrospector {
/** The default prefix for write methods. */
public static final String DEFAULT_WRITE_METHOD_PREFIX = "set";
/** The logger. */
private final Log log = LogFactory.getLog(getClass());
/** The prefix of write methods to search for. */
private final String writeMethodPrefix;
/**
*
* Creates a new instance of FluentPropertyBeanIntrospector and
* initializes it with the prefix for write methods used by the classes to
* be inspected.
*
* @param writePrefix the prefix for write methods (must not be null )
* @throws IllegalArgumentException if the prefix is null
*/
public FluentPropertyBeanIntrospector(String writePrefix) {
if (writePrefix == null) {
throw new IllegalArgumentException(
"Prefix for write methods must not be null!");
}
writeMethodPrefix = writePrefix;
}
/**
*
* Creates a new instance of FluentPropertyBeanIntrospector and
* sets the default prefix for write methods.
*/
public FluentPropertyBeanIntrospector() {
this(DEFAULT_WRITE_METHOD_PREFIX);
}
/**
* Returns the prefix for write methods this instance scans for.
*
* @return the prefix for write methods
*/
public String getWriteMethodPrefix() {
return writeMethodPrefix;
}
/**
* Performs introspection. This method scans the current class's methods for
* property write methods which have not been discovered by default
* introspection.
*
* @param icontext the introspection context
* @throws IntrospectionException if an error occurs
*/
public void introspect(IntrospectionContext icontext)
throws IntrospectionException {
for (Method m : icontext.getTargetClass().getMethods()) {
if (m.getName().startsWith(getWriteMethodPrefix())) {
String propertyName = propertyName(m);
PropertyDescriptor pd = icontext
.getPropertyDescriptor(propertyName);
try {
if (pd == null) {
icontext.addPropertyDescriptor(createFluentPropertyDescritor(
m, propertyName));
} else if (pd.getWriteMethod() == null) {
pd.setWriteMethod(m);
}
} catch (IntrospectionException e) {
log.warn("Error when creating PropertyDescriptor for " + m
+ "! Ignoring this property.", e);
}
}
}
}
/**
* Derives the name of a property from the given set method.
*
* @param m the method
* @return the corresponding property name
*/
private String propertyName(Method m) {
String methodName = m.getName().substring(
getWriteMethodPrefix().length());
return (methodName.length() > 1) ? Character.toLowerCase(methodName
.charAt(0)) + methodName.substring(1) : methodName
.toLowerCase(Locale.ENGLISH);
}
/**
* Creates a property descriptor for a fluent API property.
*
* @param m the set method for the fluent API property
* @param propertyName the name of the corresponding property
* @return the descriptor
* @throws IntrospectionException if an error occurs
*/
private PropertyDescriptor createFluentPropertyDescritor(Method m,
String propertyName) throws IntrospectionException {
return new PropertyDescriptor(propertyName(m), null, m);
}
} commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/IntrospectionContext.java 100644 0 0 7221 12262570610 30255 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
import java.beans.PropertyDescriptor;
import java.util.Set;
/**
*
* A context interface used during introspection for querying and setting
* property descriptors.
*
*
* An implementation of this interface is passed to {@link BeanIntrospector}
* objects during processing of a bean class. It allows the
* {@code BeanIntrospector} to deliver descriptors for properties it has
* detected. It is also possible to find out which properties have already been
* found by another {@code BeanIntrospector}; this allows multiple
* {@code BeanIntrospector} instances to collaborate.
*
*
* @version $Id: IntrospectionContext.java 1540359 2013-11-09 18:10:52Z oheger $
* @since 1.9
*/
public interface IntrospectionContext {
/**
* Returns the class that is subject of introspection.
*
* @return the current class
*/
Class getTargetClass();
/**
* Adds the given property descriptor to this context. This method is called
* by a {@code BeanIntrospector} during introspection for each detected
* property. If this context already contains a descriptor for the affected
* property, it is overridden.
*
* @param desc the property descriptor
*/
void addPropertyDescriptor(PropertyDescriptor desc);
/**
* Adds an array of property descriptors to this context. Using this method
* multiple descriptors can be added at once.
*
* @param descriptors the array of descriptors to be added
*/
void addPropertyDescriptors(PropertyDescriptor[] descriptors);
/**
* Tests whether a descriptor for the property with the given name is
* already contained in this context. This method can be used for instance
* to prevent that an already existing property descriptor is overridden.
*
* @param name the name of the property in question
* @return true if a descriptor for this property has already been
* added, false otherwise
*/
boolean hasProperty(String name);
/**
* Returns the descriptor for the property with the given name or
* null if this property is unknown.
*
* @param name the name of the property in question
* @return the descriptor for this property or null if this property
* is unknown
*/
PropertyDescriptor getPropertyDescriptor(String name);
/**
* Removes the descriptor for the property with the given name.
*
* @param name the name of the affected property
*/
void removePropertyDescriptor(String name);
/**
* Returns a set with the names of all properties known to this context.
*
* @return a set with the known property names
*/
Set propertyNames();
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/JDBCDynaClass.java 100644 0 0 25322 12262570612 26400 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
import java.io.Serializable;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
/**
* Provides common logic for JDBC implementations of {@link DynaClass}.
*
* @version $Id: JDBCDynaClass.java 1540186 2013-11-08 21:08:30Z oheger $
*/
abstract class JDBCDynaClass implements DynaClass, Serializable {
// ----------------------------------------------------- Instance Variables
/**
* Flag defining whether column names should be lower cased when
* converted to property names.
*/
protected boolean lowerCase = true;
/**
* Flag defining whether column names or labels should be used.
*/
private boolean useColumnLabel;
/**
*
The set of dynamic properties that are part of this
* {@link DynaClass}.
*/
protected DynaProperty[] properties = null;
/**
* The set of dynamic properties that are part of this
* {@link DynaClass}, keyed by the property name. Individual descriptor
* instances will be the same instances as those in the
* properties list.
*/
protected Map propertiesMap = new HashMap();
/**
* Cross Reference for column name --> dyna property name
* (needed when lowerCase option is true)
*/
private Map columnNameXref;
// ------------------------------------------------------ DynaClass Methods
/**
* Return the name of this DynaClass (analogous to the
* getName() method of java.lang.ClassDynaClass implementation class to support
* different dynamic classes, with different sets of properties.
*/
public String getName() {
return (this.getClass().getName());
}
/**
* Return a property descriptor for the specified property, if it
* exists; otherwise, return null.
*
* @param name Name of the dynamic property for which a descriptor
* is requested
*
* @exception IllegalArgumentException if no property name is specified
*/
public DynaProperty getDynaProperty(String name) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
return (propertiesMap.get(name));
}
/**
* 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.
*/
public DynaProperty[] getDynaProperties() {
return (properties);
}
/**
* Instantiate and return a new DynaBean instance, associated
* with this DynaClass. NOTE - This operation is not
* supported, and throws an exception.
*
* @exception IllegalAccessException if the Class or the appropriate
* constructor is not accessible
* @exception InstantiationException if this Class represents an abstract
* class, an array class, a primitive type, or void; or if instantiation
* fails for some other reason
*/
public DynaBean newInstance()
throws IllegalAccessException, InstantiationException {
throw new UnsupportedOperationException("newInstance() not supported");
}
/**
* Set whether the column label or name should be used for the property name.
*
* @param useColumnLabel true if the column label should be used, otherwise false
*/
public void setUseColumnLabel(boolean useColumnLabel) {
this.useColumnLabel = useColumnLabel;
}
/**
* Loads and returns the Class of the given name.
* By default, a load from the thread context class loader is attempted.
* If there is no such class loader, the class loader used to load this
* class will be utilized.
*
* @param className The name of the class to load
* @return The loaded class
* @exception SQLException if an exception was thrown trying to load
* the specified class
*/
protected Class loadClass(String className) throws SQLException {
try {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
if (cl == null) {
cl = this.getClass().getClassLoader();
}
// use Class.forName() - see BEANUTILS-327
return Class.forName(className, false, cl);
} catch (Exception e) {
throw new SQLException(
"Cannot load column class '" + className + "': " + e);
}
}
/**
* Factory method to create a new DynaProperty for the given index
* into the result set metadata.
*
* @param metadata is the result set metadata
* @param i is the column index in the metadata
* @return the newly created DynaProperty instance
* @throws SQLException If an error occurs accessing the SQL metadata
*/
protected DynaProperty createDynaProperty(
ResultSetMetaData metadata,
int i)
throws SQLException {
String columnName = null;
if (useColumnLabel) {
columnName = metadata.getColumnLabel(i);
}
if (columnName == null || columnName.trim().length() == 0) {
columnName = metadata.getColumnName(i);
}
String name = lowerCase ? columnName.toLowerCase() : columnName;
if (!name.equals(columnName)) {
if (columnNameXref == null) {
columnNameXref = new HashMap();
}
columnNameXref.put(name, columnName);
}
String className = null;
try {
int sqlType = metadata.getColumnType(i);
switch (sqlType) {
case java.sql.Types.DATE:
return new DynaProperty(name, java.sql.Date.class);
case java.sql.Types.TIMESTAMP:
return new DynaProperty(name, java.sql.Timestamp.class);
case java.sql.Types.TIME:
return new DynaProperty(name, java.sql.Time.class);
default:
className = metadata.getColumnClassName(i);
}
} catch (SQLException e) {
// this is a patch for HsqlDb to ignore exceptions
// thrown by its metadata implementation
}
// Default to Object type if no class name could be retrieved
// from the metadata
Class clazz = Object.class;
if (className != null) {
clazz = loadClass(className);
}
return new DynaProperty(name, clazz);
}
/**
* Introspect the metadata associated with our result set, and populate
* the properties and propertiesMap instance
* variables.
*
* @param resultSet The resultSet whose metadata is to
* be introspected
*
* @exception SQLException if an error is encountered processing the
* result set metadata
*/
protected void introspect(ResultSet resultSet) throws SQLException {
// Accumulate an ordered list of DynaProperties
ArrayList list = new ArrayList();
ResultSetMetaData metadata = resultSet.getMetaData();
int n = metadata.getColumnCount();
for (int i = 1; i <= n; i++) { // JDBC is one-relative!
DynaProperty dynaProperty = createDynaProperty(metadata, i);
if (dynaProperty != null) {
list.add(dynaProperty);
}
}
// Convert this list into the internal data structures we need
properties =
list.toArray(new DynaProperty[list.size()]);
for (int i = 0; i < properties.length; i++) {
propertiesMap.put(properties[i].getName(), properties[i]);
}
}
/**
* Get a column value from a {@link ResultSet} for the specified name.
*
* @param resultSet The result set
* @param name The property name
* @return The value
* @throws SQLException if an error occurs
*/
protected Object getObject(ResultSet resultSet, String name) throws SQLException {
DynaProperty property = getDynaProperty(name);
if (property == null) {
throw new IllegalArgumentException("Invalid name '" + name + "'");
}
String columnName = getColumnName(name);
Class type = property.getType();
// java.sql.Date
if (type.equals(Date.class)) {
return resultSet.getDate(columnName);
}
// java.sql.Timestamp
if (type.equals(Timestamp.class)) {
return resultSet.getTimestamp(columnName);
}
// java.sql.Time
if (type.equals(Time.class)) {
return resultSet.getTime(columnName);
}
return resultSet.getObject(columnName);
}
/**
* Get the table column name for the specified property name.
*
* @param name The property name
* @return The column name (which can be different if the lowerCase
* option is used).
*/
protected String getColumnName(String name) {
if (columnNameXref != null && columnNameXref.containsKey(name)) {
return columnNameXref.get(name);
} else {
return name;
}
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/LazyDynaBean.java 100644 0 0 103242 12262570612 26433 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* DynaBean which automatically adds properties to the DynaClass
* and provides Lazy List and Lazy Map features.
*
* DynaBeans deal with three types of properties - simple , indexed and mapped and
* have the following get() and set() methods for
* each of these types:
*
* Simple property methods - get(name) and
* set(name, value)Indexed property methods - get(name, index) and
* set(name, index, value)Mapped property methods - get(name, key) and
* set(name, key, value)
*
* Getting Property Values
* Calling any of the get() methods, for a property which
* doesn't exist, returns null in this implementation.
*
* Setting Simple Properties
* The LazyDynaBean will automatically add a property to the DynaClass
* if it doesn't exist when the set(name, value) method is called.
*
* DynaBean myBean = new LazyDynaBean();
* myBean.set("myProperty", "myValue");
*
* Setting Indexed Properties
* If the property doesn't exist, the LazyDynaBean will automatically add
* a property with an ArrayList type to the DynaClass when
* the set(name, index, value) method is called.
* It will also instantiate a new ArrayList and automatically grow
* the List so that it is big enough to accomodate the index being set.
* ArrayList is the default indexed property that LazyDynaBean uses but
* this can be easily changed by overriding the defaultIndexedProperty(name)
* method.
*
* DynaBean myBean = new LazyDynaBean();
* myBean.set("myIndexedProperty", 0, "myValue1");
* myBean.set("myIndexedProperty", 1, "myValue2");
*
* If the indexed property does exist in the DynaClass but is set to
* null in the LazyDynaBean, then it will instantiate a
* new List or Array as specified by the property's type
* in the DynaClass and automatically grow the List
* or Array so that it is big enough to accomodate the index being set.
*
* DynaBean myBean = new LazyDynaBean();
* MutableDynaClass myClass = (MutableDynaClass)myBean.getDynaClass();
* myClass.add("myIndexedProperty", int[].class);
* myBean.set("myIndexedProperty", 0, new Integer(10));
* myBean.set("myIndexedProperty", 1, new Integer(20));
*
* Setting Mapped Properties
* If the property doesn't exist, the LazyDynaBean will automatically add
* a property with a HashMap type to the DynaClass and
* instantiate a new HashMap in the DynaBean when the
* set(name, key, value) method is called. HashMap is the default
* mapped property that LazyDynaBean uses but this can be easily changed by overriding
* the defaultMappedProperty(name) method.
*
* DynaBean myBean = new LazyDynaBean();
* myBean.set("myMappedProperty", "myKey", "myValue");
*
* If the mapped property does exist in the DynaClass but is set to
* null in the LazyDynaBean, then it will instantiate a
* new Map as specified by the property's type in the DynaClass.
*
* DynaBean myBean = new LazyDynaBean();
* MutableDynaClass myClass = (MutableDynaClass)myBean.getDynaClass();
* myClass.add("myMappedProperty", TreeMap.class);
* myBean.set("myMappedProperty", "myKey", "myValue");
*
* Restricted DynaClass
* 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: LazyDynaBean.java 1540504 2013-11-10 18:22:57Z niallp $
* @see LazyDynaClass
*/
public class LazyDynaBean implements DynaBean, Serializable {
/**
* Commons Logging
*/
private transient Log logger = LogFactory.getLog(LazyDynaBean.class);
/** BigInteger Zero */
protected static final BigInteger BigInteger_ZERO = new BigInteger("0");
/** BigDecimal Zero */
protected static final BigDecimal BigDecimal_ZERO = new BigDecimal("0");
/** Character Space */
protected static final Character Character_SPACE = new Character(' ');
/** Byte Zero */
protected static final Byte Byte_ZERO = new Byte((byte)0);
/** Short Zero */
protected static final Short Short_ZERO = new Short((short)0);
/** Integer Zero */
protected static final Integer Integer_ZERO = new Integer(0);
/** Long Zero */
protected static final Long Long_ZERO = new Long(0);
/** Float Zero */
protected static final Float Float_ZERO = new Float((byte)0);
/** Double Zero */
protected static final Double Double_ZERO = new Double((byte)0);
/**
* The MutableDynaClass "base class" that this DynaBean
* is associated with.
*/
protected Map values;
/** Map decorator for this DynaBean */
private transient Map mapDecorator;
/**
* The MutableDynaClass "base class" that this DynaBean
* is associated with.
*/
protected MutableDynaClass dynaClass;
// ------------------- Constructors ----------------------------------
/**
* Construct a new LazyDynaBean with a LazyDynaClass instance.
*/
public LazyDynaBean() {
this(new LazyDynaClass());
}
/**
* Construct a new LazyDynaBean with a LazyDynaClass instance.
*
* @param name Name of this DynaBean class
*/
public LazyDynaBean(String name) {
this(new LazyDynaClass(name));
}
/**
* Construct a new DynaBean associated with the specified
* DynaClass instance - if its not a MutableDynaClass
* then a new LazyDynaClass is created and the properties copied.
*
* @param dynaClass The DynaClass we are associated with
*/
public LazyDynaBean(DynaClass dynaClass) {
values = newMap();
if (dynaClass instanceof MutableDynaClass) {
this.dynaClass = (MutableDynaClass)dynaClass;
} else {
this.dynaClass = new LazyDynaClass(dynaClass.getName(), dynaClass.getDynaProperties());
}
}
// ------------------- Public Methods ----------------------------------
/**
* Return a Map representation of this DynaBean.
*
* This, for example, could be used in JSTL in the following way to access
* a DynaBean's fooProperty:
* ${myDynaBean.map .fooProperty} getMap() {
// cache the Map
if (mapDecorator == null) {
mapDecorator = new DynaBeanPropertyMapDecorator(this);
}
return mapDecorator;
}
/**
* Return the size of an indexed or mapped property.
*
* @param name Name of the property
* @return The indexed or mapped property size
* @exception IllegalArgumentException if no property name is specified
*/
public int size(String name) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
Object value = values.get(name);
if (value == null) {
return 0;
}
if (value instanceof Map) {
return ((Map)value).size();
}
if (value instanceof List) {
return ((List)value).size();
}
if ((value.getClass().isArray())) {
return Array.getLength(value);
}
return 0;
}
// ------------------- DynaBean Methods ----------------------------------
/**
* Does the specified mapped property contain a value for the specified
* key value?
*
* @param name Name of the property to check
* @param key Name of the key to check
* @return true if the mapped property contains a value for
* the specified key, otherwise false
*
* @exception IllegalArgumentException if no property name is specified
*/
public boolean contains(String name, String key) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
Object value = values.get(name);
if (value == null) {
return false;
}
if (value instanceof Map) {
return (((Map) value).containsKey(key));
}
return false;
}
/**
* Return the value of a simple property with the specified name.
*
* N.B. Returns null if there is no property
* of the specified name.
*
* @param name Name of the property whose value is to be retrieved.
* @return The property's value
* @exception IllegalArgumentException if no property name is specified
*/
public Object get(String name) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
// Value found
Object value = values.get(name);
if (value != null) {
return value;
}
// Property doesn't exist
if (!isDynaProperty(name)) {
return null;
}
// Property doesn't exist
value = createProperty(name, dynaClass.getDynaProperty(name).getType());
if (value != null) {
set(name, value);
}
return value;
}
/**
* Return the value of an indexed property with the specified name.
*
* N.B. Returns null if there is no 'indexed'
* property of the specified name.
*
* @param name Name of the property whose value is to be retrieved
* @param index Index of the value to be retrieved
* @return The indexed property's value
*
* @exception IllegalArgumentException if the specified property
* exists, but is not indexed
* @exception IndexOutOfBoundsException if the specified index
* is outside the range of the underlying property
*/
public Object get(String name, int index) {
// If its not a property, then create default indexed property
if (!isDynaProperty(name)) {
set(name, defaultIndexedProperty(name));
}
// Get the indexed property
Object indexedProperty = get(name);
// Check that the property is indexed
if (!dynaClass.getDynaProperty(name).isIndexed()) {
throw new IllegalArgumentException
("Non-indexed property for '" + name + "[" + index + "]' "
+ dynaClass.getDynaProperty(name).getName());
}
// Grow indexed property to appropriate size
indexedProperty = growIndexedProperty(name, indexedProperty, index);
// Return the indexed value
if (indexedProperty.getClass().isArray()) {
return Array.get(indexedProperty, index);
} else if (indexedProperty instanceof List) {
return ((List)indexedProperty).get(index);
} else {
throw new IllegalArgumentException
("Non-indexed property for '" + name + "[" + index + "]' "
+ indexedProperty.getClass().getName());
}
}
/**
* Return the value of a mapped property with the specified name.
*
* N.B. Returns null if there is no 'mapped'
* property of the specified name.
*
* @param name Name of the property whose value is to be retrieved
* @param key Key of the value to be retrieved
* @return The mapped property's value
*
* @exception IllegalArgumentException if the specified property
* exists, but is not mapped
*/
public Object get(String name, String key) {
// If its not a property, then create default mapped property
if (!isDynaProperty(name)) {
set(name, defaultMappedProperty(name));
}
// Get the mapped property
Object mappedProperty = get(name);
// Check that the property is mapped
if (!dynaClass.getDynaProperty(name).isMapped()) {
throw new IllegalArgumentException
("Non-mapped property for '" + name + "(" + key + ")' "
+ dynaClass.getDynaProperty(name).getType().getName());
}
// Get the value from the Map
if (mappedProperty instanceof Map) {
return (((Map) mappedProperty).get(key));
} else {
throw new IllegalArgumentException
("Non-mapped property for '" + name + "(" + key + ")'"
+ mappedProperty.getClass().getName());
}
}
/**
* Return the DynaClass instance that describes the set of
* properties available for this DynaBean.
*
* @return The associated DynaClass
*/
public DynaClass getDynaClass() {
return dynaClass;
}
/**
* Remove any existing value for the specified key on the
* specified mapped property.
*
* @param name Name of the property for which a value is to
* be removed
* @param key Key of the value to be removed
*
* @exception IllegalArgumentException if there is no property
* of the specified name
*/
public void remove(String name, String key) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
Object value = values.get(name);
if (value == null) {
return;
}
if (value instanceof Map) {
((Map) value).remove(key);
} else {
throw new IllegalArgumentException
("Non-mapped property for '" + name + "(" + key + ")'"
+ value.getClass().getName());
}
}
/**
* 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
*
* @exception IllegalArgumentException if this is not an existing property
* name for our DynaClass and the MutableDynaClass is restricted
* @exception ConversionException if the specified value cannot be
* converted to the type required for this property
* @exception NullPointerException if an attempt is made to set a
* primitive property to null
*/
public void set(String name, Object value) {
// If the property doesn't exist, then add it
if (!isDynaProperty(name)) {
if (dynaClass.isRestricted()) {
throw new IllegalArgumentException
("Invalid property name '" + name + "' (DynaClass is restricted)");
}
if (value == null) {
dynaClass.add(name);
} else {
dynaClass.add(name, value.getClass());
}
}
DynaProperty descriptor = dynaClass.getDynaProperty(name);
if (value == null) {
if (descriptor.getType().isPrimitive()) {
throw new NullPointerException
("Primitive value for '" + name + "'");
}
} else if (!isAssignable(descriptor.getType(), value.getClass())) {
throw new ConversionException
("Cannot assign value of type '" +
value.getClass().getName() +
"' to property '" + name + "' of type '" +
descriptor.getType().getName() + "'");
}
// Set the property's value
values.put(name, value);
}
/**
* Set the value of an indexed property with the specified name.
*
* @param name Name of the property whose value is to be set
* @param index Index of the property to be set
* @param value Value to which this property is to be set
*
* @exception ConversionException if the specified value cannot be
* converted to the type required for this property
* @exception IllegalArgumentException if there is no property
* of the specified name
* @exception IllegalArgumentException if the specified property
* exists, but is not indexed
* @exception IndexOutOfBoundsException if the specified index
* is outside the range of the underlying property
*/
public void set(String name, int index, Object value) {
// If its not a property, then create default indexed property
if (!isDynaProperty(name)) {
set(name, defaultIndexedProperty(name));
}
// Get the indexed property
Object indexedProperty = get(name);
// Check that the property is indexed
if (!dynaClass.getDynaProperty(name).isIndexed()) {
throw new IllegalArgumentException
("Non-indexed property for '" + name + "[" + index + "]'"
+ dynaClass.getDynaProperty(name).getType().getName());
}
// Grow indexed property to appropriate size
indexedProperty = growIndexedProperty(name, indexedProperty, index);
// Set the value in an array
if (indexedProperty.getClass().isArray()) {
Array.set(indexedProperty, index, value);
} else if (indexedProperty instanceof List) {
@SuppressWarnings("unchecked")
// Indexed properties are stored in a List
List values = (List) indexedProperty;
values.set(index, value);
} else {
throw new IllegalArgumentException
("Non-indexed property for '" + name + "[" + index + "]' "
+ indexedProperty.getClass().getName());
}
}
/**
* Set the value of a mapped property with the specified name.
*
* @param name Name of the property whose value is to be set
* @param key Key of the property to be set
* @param value Value to which this property is to be set
*
* @exception ConversionException if the specified value cannot be
* converted to the type required for this property
* @exception IllegalArgumentException if there is no property
* of the specified name
* @exception IllegalArgumentException if the specified property
* exists, but is not mapped
*/
public void set(String name, String key, Object value) {
// If the 'mapped' property doesn't exist, then add it
if (!isDynaProperty(name)) {
set(name, defaultMappedProperty(name));
}
// Get the mapped property
Object mappedProperty = get(name);
// Check that the property is mapped
if (!dynaClass.getDynaProperty(name).isMapped()) {
throw new IllegalArgumentException
("Non-mapped property for '" + name + "(" + key + ")'"
+ dynaClass.getDynaProperty(name).getType().getName());
}
// Set the value in the Map
@SuppressWarnings("unchecked")
// mapped properties are stored in a Map
Map valuesMap = (Map) mappedProperty;
valuesMap.put(key, value);
}
// ------------------- protected Methods ----------------------------------
/**
* Grow the size of an indexed property
* @param name The name of the property
* @param indexedProperty The current property value
* @param index The indexed value to grow the property to (i.e. one less than
* the required size)
* @return The new property value (grown to the appropriate size)
*/
protected Object growIndexedProperty(String name, Object indexedProperty, int index) {
// Grow a List to the appropriate size
if (indexedProperty instanceof List) {
@SuppressWarnings("unchecked")
// Indexed properties are stored as List
List list = (List)indexedProperty;
while (index >= list.size()) {
Class contentType = getDynaClass().getDynaProperty(name).getContentType();
Object value = null;
if (contentType != null) {
value = createProperty(name+"["+list.size()+"]", contentType);
}
list.add(value);
}
}
// Grow an Array to the appropriate size
if ((indexedProperty.getClass().isArray())) {
int length = Array.getLength(indexedProperty);
if (index >= length) {
Class componentType = indexedProperty.getClass().getComponentType();
Object newArray = Array.newInstance(componentType, (index + 1));
System.arraycopy(indexedProperty, 0, newArray, 0, length);
indexedProperty = newArray;
set(name, indexedProperty);
int newLength = Array.getLength(indexedProperty);
for (int i = length; i < newLength; i++) {
Array.set(indexedProperty, i, createProperty(name+"["+i+"]", componentType));
}
}
}
return indexedProperty;
}
/**
* Create a new Instance of a Property
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createProperty(String name, Class type) {
if (type == null) {
return null;
}
// Create Lists, arrays or DynaBeans
if (type.isArray() || List.class.isAssignableFrom(type)) {
return createIndexedProperty(name, type);
}
if (Map.class.isAssignableFrom(type)) {
return createMappedProperty(name, type);
}
if (DynaBean.class.isAssignableFrom(type)) {
return createDynaBeanProperty(name, type);
}
if (type.isPrimitive()) {
return createPrimitiveProperty(name, type);
}
if (Number.class.isAssignableFrom(type)) {
return createNumberProperty(name, type);
}
return createOtherProperty(name, type);
}
/**
* Create a new Instance of an 'Indexed' Property
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createIndexedProperty(String name, Class type) {
// Create the indexed object
Object indexedProperty = null;
if (type == null) {
indexedProperty = defaultIndexedProperty(name);
} else if (type.isArray()) {
indexedProperty = Array.newInstance(type.getComponentType(), 0);
} else if (List.class.isAssignableFrom(type)) {
if (type.isInterface()) {
indexedProperty = defaultIndexedProperty(name);
} else {
try {
indexedProperty = type.newInstance();
}
catch (Exception ex) {
throw new IllegalArgumentException
("Error instantiating indexed property of type '" +
type.getName() + "' for '" + name + "' " + ex);
}
}
} else {
throw new IllegalArgumentException
("Non-indexed property of type '" + type.getName() + "' for '" + name + "'");
}
return indexedProperty;
}
/**
* Create a new Instance of a 'Mapped' Property
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createMappedProperty(String name, Class type) {
// Create the mapped object
Object mappedProperty = null;
if (type == null) {
mappedProperty = defaultMappedProperty(name);
} else if (type.isInterface()) {
mappedProperty = defaultMappedProperty(name);
} else if (Map.class.isAssignableFrom(type)) {
try {
mappedProperty = type.newInstance();
}
catch (Exception ex) {
throw new IllegalArgumentException
("Error instantiating mapped property of type '" +
type.getName() + "' for '" + name + "' " + ex);
}
} else {
throw new IllegalArgumentException
("Non-mapped property of type '" + type.getName() + "' for '" + name + "'");
}
return mappedProperty;
}
/**
* Create a new Instance of a 'DynaBean' Property.
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createDynaBeanProperty(String name, Class type) {
try {
return type.newInstance();
}
catch (Exception ex) {
if (logger().isWarnEnabled()) {
logger().warn("Error instantiating DynaBean property of type '" +
type.getName() + "' for '" + name + "' " + ex);
}
return null;
}
}
/**
* Create a new Instance of a 'Primitive' Property.
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createPrimitiveProperty(String name, Class type) {
if (type == Boolean.TYPE) {
return Boolean.FALSE;
} else if (type == Integer.TYPE) {
return Integer_ZERO;
} else if (type == Long.TYPE) {
return Long_ZERO;
} else if (type == Double.TYPE) {
return Double_ZERO;
} else if (type == Float.TYPE) {
return Float_ZERO;
} else if (type == Byte.TYPE) {
return Byte_ZERO;
} else if (type == Short.TYPE) {
return Short_ZERO;
} else if (type == Character.TYPE) {
return Character_SPACE;
} else {
return null;
}
}
/**
* Create a new Instance of a java.lang.Number Property.
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createNumberProperty(String name, Class type) {
return null;
}
/**
* Create a new Instance of other Property types
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createOtherProperty(String name, Class type) {
if (type == Object.class ||
type == String.class ||
type == Boolean.class ||
type == Character.class ||
Date.class.isAssignableFrom(type)) {
return null;
}
try {
return type.newInstance();
}
catch (Exception ex) {
if (logger().isWarnEnabled()) {
logger().warn("Error instantiating property of type '" + type.getName() + "' for '" + name + "' " + ex);
}
return null;
}
}
/**
* Creates a new ArrayList for an 'indexed' property
* which doesn't exist.
*
* This method should be overridden if an alternative List
* or Array implementation is required for 'indexed' properties.
*
* @param name Name of the 'indexed property.
* @return The default value for an indexed property (java.util.ArrayList)
*/
protected Object defaultIndexedProperty(String name) {
return new ArrayList();
}
/**
* Creates a new HashMap for a 'mapped' property
* which doesn't exist.
*
* This method can be overridden if an alternative Map
* implementation is required for 'mapped' properties.
*
* @param name Name of the 'mapped property.
* @return The default value for a mapped property (java.util.HashMap)
*/
protected Map defaultMappedProperty(String name) {
return new HashMap();
}
/**
* Indicates if there is a property with the specified name.
* @param name The name of the property to check
* @return true if there is a property of the
* specified name, otherwise false
*/
protected boolean isDynaProperty(String name) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
// Handle LazyDynaClasses
if (dynaClass instanceof LazyDynaClass) {
return ((LazyDynaClass)dynaClass).isDynaProperty(name);
}
// Handle other MutableDynaClass
return dynaClass.getDynaProperty(name) == null ? false : true;
}
/**
* Is an object of the source class assignable to the destination class?
*
* @param dest Destination class
* @param source Source class
* @return true if the source class is assignable to the
* destination class, otherwise false
*/
protected boolean isAssignable(Class dest, Class source) {
if (dest.isAssignableFrom(source) ||
((dest == Boolean.TYPE) && (source == Boolean.class)) ||
((dest == Byte.TYPE) && (source == Byte.class)) ||
((dest == Character.TYPE) && (source == Character.class)) ||
((dest == Double.TYPE) && (source == Double.class)) ||
((dest == Float.TYPE) && (source == Float.class)) ||
((dest == Integer.TYPE) && (source == Integer.class)) ||
((dest == Long.TYPE) && (source == Long.class)) ||
((dest == Short.TYPE) && (source == Short.class))) {
return (true);
} else {
return (false);
}
}
/**
* Creates a new instance of the Map.
* @return a new Map instance
*/
protected Map newMap() {
return new HashMap();
}
/**
* Returns the Log.
*/
private Log logger() {
if (logger == null) {
logger = LogFactory.getLog(LazyDynaBean.class);
}
return logger;
}
}
commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/LazyDynaClass.java 100644 0 0 33615 12262570612 26621 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
/**
*
DynaClass which implements the MutableDynaClass interface.
*
* A MutableDynaClass is a specialized extension to DynaClass
* that allows properties to be added or removed dynamically.
*
* This implementation has one slightly unusual default behaviour - calling
* the getDynaProperty(name) method for a property which doesn't
* exist returns a DynaProperty rather than null. The
* reason for this is that BeanUtils calls this method to check if
* a property exists before trying to set the value. This would defeat the object
* of the LazyDynaBean which automatically adds missing properties
* when any of its set() methods are called. For this reason the
* isDynaProperty(name) method has been added to this implementation
* in order to determine if a property actually exists. If the more normal
* behaviour of returning null is required, then this can be achieved
* by calling the setReturnNull(true).
*
* The add(name, type, readable, writable) method is not implemented
* and always throws an UnsupportedOperationException. I believe
* this attributes need to be added to the DynaProperty class
* in order to control read/write facilities.
*
* @version $Id: LazyDynaClass.java 1540504 2013-11-10 18:22:57Z niallp $
* @see LazyDynaBean
*/
public class LazyDynaClass extends BasicDynaClass implements MutableDynaClass {
/**
* 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;
/**
* Construct a new LazyDynaClass with default parameters.
*/
public LazyDynaClass() {
this(null, (DynaProperty[])null);
}
/**
* Construct a new LazyDynaClass with the specified name.
*
* @param name Name of this DynaBean class
*/
public LazyDynaClass(String name) {
this(name, (DynaProperty[])null);
}
/**
* Construct a new LazyDynaClass with the specified name and DynaBean class.
*
* @param name Name of this DynaBean class
* @param dynaBeanClass The implementation class for new instances
*/
public LazyDynaClass(String name, Class dynaBeanClass) {
this(name, dynaBeanClass, null);
}
/**
* Construct a new LazyDynaClass with the specified name and properties.
*
* @param name Name of this DynaBean class
* @param properties Property descriptors for the supported properties
*/
public LazyDynaClass(String name, DynaProperty[] properties) {
this(name, LazyDynaBean.class, properties);
}
/**
* Construct a new LazyDynaClass with the specified name, DynaBean class and properties.
*
* @param name Name of this DynaBean class
* @param dynaBeanClass The implementation class for new instances
* @param properties Property descriptors for the supported properties
*/
public LazyDynaClass(String name, Class dynaBeanClass, DynaProperty properties[]) {
super(name, dynaBeanClass, properties);
}
/**
*
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 {@link MutableDynaClass} cannot be changed
* otherwise false
*/
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 true if this {@link MutableDynaClass} cannot
* be changed otherwise false
*/
public void setRestricted(boolean restricted) {
this.restricted = restricted;
}
/**
* 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(boolean returnNull) {
this.returnNull = returnNull;
}
/**
* Add a new dynamic property with no restrictions on data type,
* readability, or writeability.
*
* @param name Name of the new dynamic property
*
* @exception IllegalArgumentException if name is null
* @exception IllegalStateException if this DynaClass is currently
* restricted, so no new properties can be added
*/
public void add(String name) {
add(new DynaProperty(name));
}
/**
* 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)
*
* @exception IllegalArgumentException if name is null
* @exception IllegalStateException if this DynaClass is currently
* restricted, so no new properties can be added
*/
public void add(String name, Class type) {
if (type == null) {
add(name);
} else {
add(new DynaProperty(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
*
* @exception UnsupportedOperationException anytime this method is called
*/
public void add(String name, Class type, boolean readable, 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.
*
* @exception IllegalArgumentException if name is null
* @exception IllegalStateException if this DynaClass is currently
* restricted, so no new properties can be added
*/
protected void add(DynaProperty property) {
if (property.getName() == null) {
throw new IllegalArgumentException("Property name is missing.");
}
if (isRestricted()) {
throw new IllegalStateException("DynaClass is currently restricted. No new properties can be added.");
}
// Check if property already exists
if (propertiesMap.get(property.getName()) != null) {
return;
}
// Create a new property array with the specified property
DynaProperty[] oldProperties = getDynaProperties();
DynaProperty[] newProperties = new DynaProperty[oldProperties.length+1];
System.arraycopy(oldProperties, 0, newProperties, 0, oldProperties.length);
newProperties[oldProperties.length] = property;
// Update the properties
setProperties(newProperties);
}
/**
* 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
*
* @exception IllegalArgumentException if name is null
* @exception IllegalStateException if this DynaClass is currently
* restricted, so no properties can be removed
*/
public void remove(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.");
}
// Ignore if property doesn't exist
if (propertiesMap.get(name) == null) {
return;
}
// Create a new property array of without the specified property
DynaProperty[] oldProperties = getDynaProperties();
DynaProperty[] newProperties = new DynaProperty[oldProperties.length-1];
int j = 0;
for (int i = 0; i < oldProperties.length; i++) {
if (!(name.equals(oldProperties[i].getName()))) {
newProperties[j] = oldProperties[i];
j++;
}
}
// Update the properties
setProperties(newProperties);
}
/**
* 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 Lazy 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 dyna property for the specified name
*
* @exception IllegalArgumentException if no property name is specified
*/
@Override
public DynaProperty getDynaProperty(String name) {
if (name == null) {
throw new IllegalArgumentException("Property name is missing.");
}
DynaProperty dynaProperty = propertiesMap.get(name);
// If it doesn't exist and returnNull is false
// create a new DynaProperty
if (dynaProperty == null && !isReturnNull() && !isRestricted()) {
dynaProperty = new DynaProperty(name);
}
return dynaProperty;
}
/**
* 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 The name of the property to check
* @return true if there is a property of the
* specified name, otherwise false
* @exception IllegalArgumentException if no property name is specified
*/
public boolean isDynaProperty(String name) {
if (name == null) {
throw new IllegalArgumentException("Property name is missing.");
}
return propertiesMap.get(name) == null ? false : true;
}
} commons-beanutils-1.9.1-src/src/main/java/org/apache/commons/beanutils/LazyDynaList.java 100644 0 0 56142 12262570612 26467 0 ustar 0 0 /*
* 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 org.apache.commons.beanutils;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
/**
* Lazy DynaBean List.There are two main purposes for this class:
*
* To provide Lazy List behaviour - automatically
* growing and populating the List
* with either DynaBean, java.util.Map
* or POJO Beans.
* To provide a straight forward way of putting a Collection
* or Array into the lazy list and a straight forward
* way to get it out again at the end.
*
*
* All elements added to the List are stored as DynaBean's:
*
* java.util.Map elements are "wrapped" in a LazyDynaMap.
* POJO Bean elements are "wrapped" in a WrapDynaBean.
* DynaBean's are stored un-changed.
*
*
* toArray()The toArray() method returns an array of the
* elements of the appropriate type. If the LazyDynaList
* is populated with java.util.Map objects a
* Map[] array is returned.
* If the list is populated with POJO Beans an appropriate
* array of the POJO Beans is returned. Otherwise a DynaBean[]
* array is returned.
*
*
* toDynaBeanArray()The toDynaBeanArray() method returns a
* DynaBean[] array of the elements in the List.
*
*
* N.B. All the elements in the List must be the
* same type. If the DynaClass or Class
* of the LazyDynaList's elements is
* not specified, then it will be automatically set to the type
* of the first element populated.
*
*
* Example 1
* If you have an array of java.util.Map[] - you can put that into
* a LazyDynaList.
*
*
* TreeMap[] myArray = .... // your Map[]
* List lazyList = new LazyDynaList(myArray);
* New elements of the appropriate Map type are
* automatically populated:
*
*
* // get(index) automatically grows the list
* DynaBean newElement = (DynaBean)lazyList.get(lazyList.size());
* newElement.put("someProperty", "someValue");
* Once you've finished you can get back an Array of the
* elements of the appropriate type:
*
*
* // Retrieve the array from the list
* TreeMap[] myArray = (TreeMap[])lazyList.toArray());
* Example 2
* Alternatively you can create an empty List and
* specify the Class for List's elements. The LazyDynaList
* uses the Class to automatically populate elements:
*
*
* // e.g. For Maps
* List lazyList = new LazyDynaList(TreeMap.class);
*
* // e.g. For POJO Beans
* List lazyList = new LazyDynaList(MyPojo.class);
*
* // e.g. For DynaBeans
* List lazyList = new LazyDynaList(MyDynaBean.class);
* Example 3
* Alternatively you can create an empty List and specify the
* DynaClass for List's elements. The LazyDynaList uses
* the DynaClass to automatically populate elements:
*
*
* // e.g. For Maps
* DynaClass dynaClass = new LazyDynaMap(new HashMap());
* List lazyList = new LazyDynaList(dynaClass);
*
* // e.g. For POJO Beans
* DynaClass dynaClass = (new WrapDynaBean(myPojo)).getDynaClass();
* List lazyList = new LazyDynaList(dynaClass);
*
* // e.g. For DynaBeans
* DynaClass dynaClass = new BasicDynaClass(properties);
* List lazyList = new LazyDynaList(dynaClass);
* N.B. You may wonder why control the type
* using a DynaClass rather than the Class
* as in the previous example - the reason is that some DynaBean
* implementations don't have a default empty constructor and
* therefore need to be instantiated using the DynaClass.newInstance()
* method.
*
* Example 4
* A slight variation - set the element type using either
* the setElementType(Class) method or the
* setElementDynaClass(DynaClass) method - then populate
* with the normal java.util.List methods(i.e.
* add(), addAll() or set()).
*
*
* // Create a new LazyDynaList (100 element capacity)
* LazyDynaList lazyList = new LazyDynaList(100);
*
* // Either Set the element type...
* lazyList.setElementType(TreeMap.class);
*
* // ...or the element DynaClass...
* lazyList.setElementDynaClass(new MyCustomDynaClass());
*
* // Populate from a collection
* lazyList.addAll(myCollection);
*
* {
/**
* The DynaClass of the List's elements.
*/
private DynaClass elementDynaClass;
/**
* The WrapDynaClass if the List's contains
* POJO Bean elements.
*
* N.B. WrapDynaClass isn't serlializable, which
* is why its stored separately in a
* transient instance variable.
*/
private transient WrapDynaClass wrapDynaClass;
/**
* The type of the List's elements.
*/
private Class elementType;
/**
* The DynaBean type of the List's elements.
*/
private Class elementDynaBeanType;
// ------------------- Constructors ------------------------------
/**
* Default Constructor.
*/
public LazyDynaList() {
super();
}
/**
* Construct a LazyDynaList with the
* specified capacity.
*
* @param capacity The initial capacity of the list.
*/
public LazyDynaList(int capacity) {
super(capacity);
}
/**
* Construct a LazyDynaList with a
* specified DynaClass for its elements.
*
* @param elementDynaClass The DynaClass of the List's elements.
*/
public LazyDynaList(DynaClass elementDynaClass) {
super();
setElementDynaClass(elementDynaClass);
}
/**
* Construct a LazyDynaList with a
* specified type for its elements.
*
* @param elementType The Type of the List's elements.
*/
public LazyDynaList(Class elementType) {
super();
setElementType(elementType);
}
/**
* Construct a LazyDynaList populated with the
* elements of a Collection.
*
* @param collection The Collection to populate the List from.
*/
public LazyDynaList(Collection collection) {
super(collection.size());
addAll(collection);
}
/**
* Construct a LazyDynaList populated with the
* elements of an Array.
*
* @param array The Array to populate the List from.
*/
public LazyDynaList(Object[] array) {
super(array.length);
for (int i = 0; i < array.length; i++) {
add(array[i]);
}
}
// ------------------- java.util.List Methods --------------------
/**
* Insert an element at the specified index position.
*
* If the index position is greater than the current
* size of the List, then the List is automatically
* grown to the appropriate size.
*
* @param index The index position to insert the new element.
* @param element The new element to add.
*/
@Override
public void add(int index, Object element) {
DynaBean dynaBean = transform(element);
growList(index);
super.add(index, dynaBean);
}
/**
* Add an element to the List.
*
* @param element The new element to add.
* @return true.
*/
@Override
public boolean add(Object element) {
DynaBean dynaBean = transform(element);
return super.add(dynaBean);
}
/**
* Add all the elements from a Collection to the list.
*
* @param collection The Collection of new elements.
* @return true if elements were added.
*/
@Override
public boolean addAll(Collection collection) {
if (collection == null || collection.size() == 0) {
return false;
}
ensureCapacity(size() + collection.size());
for (Object e : collection) {
add(e);
}
return true;
}
/**
*
Insert all the elements from a Collection into the
* list at a specified position.
*
*
If the index position is greater than the current
* size of the List, then the List is automatically
* grown to the appropriate size.
*
* @param collection The Collection of new elements.
* @param index The index position to insert the new elements at.
* @return true if elements were added.
*/
@Override
public boolean addAll(int index, Collection collection) {
if (collection == null || collection.size() == 0) {
return false;
}
ensureCapacity((index > size() ? index : size()) + collection.size());
// Call "transform" with first element, before
// List is "grown" to ensure the correct DynaClass
// is set.
if (size() == 0) {
transform(collection.iterator().next());
}
growList(index);
int currentIndex = index;
for (Object e : collection) {
add(currentIndex++, e);
}
return true;
}
/**
* Return the element at the specified position.
*
* If the position requested is greater than the current
* size of the List, then the List is automatically
* grown (and populated) to the appropriate size.
*
* @param index The index position to insert the new elements at.
* @return The element at the specified position.
*/
@Override
public Object get(int index) {
growList(index + 1);
return super.get(index);
}
/**
* Set the element at the specified position.
*
* If the position requested is greater than the current
* size of the List, then the List is automatically
* grown (and populated) to the appropriate size.
*
* @param index The index position to insert the new element at.
* @param element The new element.
* @return The new element.
*/
@Override
public Object set(int index, Object element) {
DynaBean dynaBean = transform(element);
growList(index + 1);
return super.set(index, dynaBean);
}
/**
* Converts the List to an Array.
*
* The type of Array created depends on the contents
* of the List:
*