org.bbottema.javareflection.valueconverter

Class ValueConversionHelper

java.lang.Object

org.bbottema.javareflection.valueconverter.ValueConversionHelper

public final class ValueConversionHelper
extends Object

This reflection utility class predicts (and converts) which types a specified value can be converted into. It can only do conversions of known 'common' types, which include:

• Any Number type (Integer, Character, Double, byte, etc.)
• String
• Boolean
• Character

In addition enums can be converted as well.

See Also:

IncompatibleTypeException

Constructor Summary

Constructors

Constructor and Description
ValueConversionHelper()

Method Summary

Modifier and Type	Method and Description
static Set<Class<?>>	collectCompatibleTargetTypes(Class<?> fromType)
static @NotNull Set<Class<?>>	collectRegisteredCompatibleTargetTypes(Class<?> fromType) Determines to which types the specified value (its type) can be converted to.
static @NotNull Object[]	convert(Object[] args, Class<?>[] targetTypes, boolean useOriginalValueWhenIncompatible) Converts a list of values to their converted form, as indicated by the specified targetTypes.
static <T> T	convert(@Nullable Object fromValue, Class<T> targetType) Converts a single value into a target output datatype.
static boolean	isCommonType(Class<?> c)
static boolean	isPrimitiveNumber(Class<?> targetType) Returns whether a Class is a primitive number.
static void	registerValueConverter(ValueFunction<?,?> userConverter) Registers a user-provided converter.
static void	resetDefaultConverters()
static boolean	typesCompatible(Class<?> fromType, Class<?> targetType)

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ValueConversionHelper

public ValueConversionHelper()

Method Detail

resetDefaultConverters

public static void resetDefaultConverters()

registerValueConverter

public static void registerValueConverter(ValueFunction<?,?> userConverter)

Registers a user-provided converter. User converters also act as intermediate converters, ie. if a user converter can go to int, double is automatically supported as well as common conversion.

isCommonType

public static boolean isCommonType(Class<?> c)

collectRegisteredCompatibleTargetTypes

@NotNull
public static @NotNull Set<Class<?>> collectRegisteredCompatibleTargetTypes(Class<?> fromType)

Determines to which types the specified value (its type) can be converted to. Most common types can be converted to most other common types and all types can be converted into a String using Object.toString().

Parameters:

fromType - The input type to find compatible conversion output types for

Returns:

The list with compatible conversion output types.

typesCompatible

public static boolean typesCompatible(Class<?> fromType,
                                      Class<?> targetType)

Returns:

Whether targetType can be derived from fromType.

collectCompatibleTargetTypes

public static Set<Class<?>> collectCompatibleTargetTypes(Class<?> fromType)

convert

@NotNull
public static @NotNull Object[] convert(Object[] args,
                                                  Class<?>[] targetTypes,
                                                  boolean useOriginalValueWhenIncompatible)
                                           throws IncompatibleTypeException

Converts a list of values to their converted form, as indicated by the specified targetTypes.

Parameters:

args - The list with value to convert.

targetTypes - The output types the specified values should be converted into.

useOriginalValueWhenIncompatible - Indicates whether an exception should be thrown for inconvertible values or that the original value should be used instead. Basically change mode to "convert what you can".

Returns:

Array containing converted values where convertible or the original value otherwise.

Throws:

IncompatibleTypeException - Thrown when unable to convert and not use the original value.

convert

@Nullable
public static <T> T convert(@Nullable
                                       @Nullable Object fromValue,
                                       Class<T> targetType)
                                throws IncompatibleTypeException

Converts a single value into a target output datatype. Only input/output pairs should be passed in here according to the possible conversions as determined by collectRegisteredCompatibleTargetTypes(Class).

First checks if the input and output types aren't the same. Then the conversions are checked for and done in the following order:

1. conversion to String (value.toString())

Parameters:

fromValue - The value to convert.

targetType - The target data type the value should be converted into.

Returns:

The converted value according the specified target data type.

Throws:

IncompatibleTypeException - Thrown by the various convert() methods used.

isPrimitiveNumber

public static boolean isPrimitiveNumber(Class<?> targetType)

Returns whether a Class is a primitive number.

Parameters:

targetType - The class to check whether it's a number.

Returns:

Whether specified class is a primitive number.