public abstract class ClassChanger<S extends Comparable<S>,T extends Number> extends Object
Number. For
example, it is sometime convenient to consider Date objects as if they were Long
objects for computation purpose in generic algorithms. Client can call the following method to
convert an arbitrary object to a Number:
Object someArbitraryObject = new Date(); Number myObjectAsANumber =ClassChanger.toNumber(someArbitraryObject);
| Modifier | Constructor and Description |
|---|---|
protected |
ClassChanger(Class<S> source,
Class<T> target)
Constructs a new class changer.
|
| Modifier and Type | Method and Description |
|---|---|
static <N extends Number> |
cast(Number n,
Class<N> c)
Casts the number to the specified class.
|
protected abstract T |
convert(S object)
Returns the numerical value for an object.
|
static Class<? extends Number> |
getFinestClass(Class<? extends Number> c1,
Class<? extends Number> c2)
Returns the class of the finest type.
|
static Class<? extends Number> |
getFinestClass(double value)
Returns the smallest class capable to hold the specified value.
|
static Class<?> |
getTransformedClass(Class<?> source)
Returns the target class for the specified source class, if a suitable transformation is
known.
|
static Class<? extends Number> |
getWidestClass(Class<? extends Number> c1,
Class<? extends Number> c2)
Returns the class of the widest type.
|
static Class<? extends Number> |
getWidestClass(Number n1,
Number n2)
Returns the class of the widest type.
|
protected abstract S |
inverseConvert(T value)
Returns an instance of the converted classe from a numerical value.
|
static void |
register(ClassChanger<?,?> converter)
Registers a new converter.
|
static <C extends Comparable> |
toComparable(Number value,
Class<C> classe)
Wraps the specified number as an instance of the specified classe.
|
static <K> K |
toNumber(Comparable<K> object)
Returns the numeric value for the specified object.
|
static Class<?> |
toPrimitive(Class<?> c)
Converts a wrapper class to a primitive class.
|
String |
toString()
Returns a string representation for this class changer.
|
static Class<?> |
toWrapper(Class<?> c)
Converts a primitive class to a wrapper class.
|
protected ClassChanger(Class<S> source, Class<T> target)
source - Parent class for convert(S)'s input objects.target - Parent class for convert(S)'s output objects.protected abstract T convert(S object) throws ClassCastException
object - Object to convert (may be null).ClassCastException - if object is not of the expected class.protected abstract S inverseConvert(T value)
value - The value to wrap.public String toString()
public static void register(ClassChanger<?,?> converter) throws IllegalStateException
ClassChanger will be taken in account by
the toNumber(java.lang.Comparable<K>) method. The example below register a conversion for the Date
class:
ClassChanger.register(new ClassChanger(Date.class, Long.class) {
protected Long convert(final Comparable o) {
return ((Date) o).getTime();
}
protected Comparable inverseConvert(final Number number) {
return new Date(number.longValue());
}
});
converter - The ClassChanger to add.IllegalStateException - if an other ClassChanger was already registered for the
same source class. This is usually not a concern since the registration usually
take place during the class initialization ("static" constructor).public static Class<?> getTransformedClass(Class<?> source)
Comparable subclass that will be specified as input to
convert(S). The target class is a Number subclass that will be returned as
output by convert(S). If no suitable mapping is found, then source is returned.public static <K> K toNumber(Comparable<K> object) throws ClassNotFoundException
toNumber(new Date()) returns the Date.getTime() value of the specified
date object as a Long.object - Object to convert (may be null).null if object was null; otherwise object if the supplied
object is already an instance of Number; otherwise a new number with the
numerical value.ClassNotFoundException - if object is not an instance of a registered class.public static <C extends Comparable> C toComparable(Number value, Class<C> classe) throws ClassNotFoundException
toComparable(new Long(time), Date.class) is equivalent to
new Date(time). There is of course no point to use this method if the destination
class is know at compile time. This method is useful for creating instance of classes choosen
dynamically at run time.value - The numerical value (may be null).classe - The desired classe for return value.ClassNotFoundException - if classe is not a registered class.public static Class<?> toPrimitive(Class<?> c) throws IllegalArgumentException
Double.class to Double.TYPE.c - The wrapper class.IllegalArgumentException - if the specified class is not a wrapper for a primitive.public static Class<?> toWrapper(Class<?> c) throws IllegalArgumentException
Double.TYPE to Double.class.c - The primitive class.IllegalArgumentException - if the specified class is not a primitive.public static <N extends Number> N cast(Number n, Class<N> c) throws IllegalArgumentException
Byte, Short, Integer, Long, Float or Double.IllegalArgumentExceptionpublic static Class<? extends Number> getWidestClass(Number n1, Number n2) throws IllegalArgumentException
n1 and n2 must be instance of
any of Byte, Short, Integer, Long, Float or Double types. At most one of the argument can be null.IllegalArgumentExceptionpublic static Class<? extends Number> getWidestClass(Class<? extends Number> c1, Class<? extends Number> c2) throws IllegalArgumentException
c1 and c2 must be of any of
Byte, Short, Integer, Long, Float or Double
types. At most one of the argument can be null.IllegalArgumentExceptionpublic static Class<? extends Number> getFinestClass(Class<? extends Number> c1, Class<? extends Number> c2) throws IllegalArgumentException
c1 and c2 must be of any of
Byte, Short, Integer, Long, Float or Double
types. At most one of the argument can be null.IllegalArgumentExceptionCopyright © 1996–2021 Geotools. All rights reserved.