com.univocity.parsers.annotations.helpers
Class AnnotationHelper

java.lang.Object
  com.univocity.parsers.annotations.helpers.AnnotationHelper

public class AnnotationHelper
extends Object

Helper class to process fields annotated with Parsed

Author:

uniVocity Software Pty Ltd - parsers@univocity.com

Method Summary

static boolean	allFieldsIndexBasedForParsing(Class<?> beanClass) Runs through all annotations of a given class to identify whether all annotated fields and methods (with the Parsed annotation) are mapped to a column by index.
static boolean	allFieldsIndexBasedForWriting(Class<?> beanClass) Runs through all annotations of a given class to identify whether all annotated fields and methods (with the Parsed annotation) are mapped to a column by index.
static boolean	allFieldsNameBasedForParsing(Class<?> beanClass) Runs through all annotations of a given class to identify whether all annotated fields and methods (with the Parsed annotation) are mapped to a column by name.
static boolean	allFieldsNameBasedForWriting(Class<?> beanClass) Runs through all annotations of a given class to identify whether all annotated fields and methods (with the Parsed annotation) are mapped to a column by name.
static void	applyFormatSettings(Object formatter, String[] propertiesAndValues) Applied the configuration of a formatter object (SimpleDateFormat, NumberFormat and others).
static String[]	deriveHeaderNamesFromFields(Class<?> beanClass, MethodFilter filter) Runs through all Parsed annotations of a given class to identify all header names associated with its fields
static List<Annotation>	findAllAnnotationsInPackage(AnnotatedElement annotatedElement, Package aPackage) Returns all annotations applied to an element, excluding the ones not in a given package.
static <A extends Annotation> A	findAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType) Searches for an annotation of a given type that's been applied to an element either directly (as a regular annotation) or indirectly (as a meta-annotations, i.e.
static Headers	findHeadersAnnotation(Class<?> beanClass) Searches for the Headers annotation in the hierarchy of a class
static Map<Field,PropertyWrapper>	getAllFields(Class<?> beanClass) Returns all fields available from a given class.
static List<Method>	getAnnotatedMethods(Class<?> beanClass, MethodFilter filter) Returns all methods available from a given class that have an annotation.
static Conversion	getConversion(AnnotatedElement target, Annotation annotation) Identifies the proper conversion for a given Field and an annotation from the package com.univocity.parsers.annotations
static Conversion	getConversion(Class classType, Annotation annotation) Identifies the proper conversion for a given type and an annotation from the package com.univocity.parsers.annotations
static Class<?>	getDeclaringClass(AnnotatedElement element)
static Conversion	getDefaultConversion(AnnotatedElement target) Returns the default Conversion that should be applied to the field based on its type.
static Conversion	getDefaultConversion(Class fieldType, Parsed parsed) Identifies the proper conversion for a given type
static Object	getDefaultPrimitiveValue(Class type) Returns Java's default value for a given type, in a primitive type wrapper.
static List<TransformedHeader>	getFieldSequence(Class beanClass, boolean processNested, HeaderTransformer transformer, MethodFilter filter) Returns a list of fields with Parsed annotations in the sequence they should be processed for parsing or writing.
static String	getName(AnnotatedElement element)
static Integer[]	getSelectedIndexes(Class<?> beanClass, MethodFilter filter) Runs through all Parsed annotations of a given class to identify all indexes associated with its fields
static Class<?>	getType(AnnotatedElement element)
static <T> T	newInstance(Class parent, Class<T> type, String[] args)

Methods inherited from class java.lang.Object

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

Method Detail

getConversion

public static Conversion getConversion(AnnotatedElement target,
                                       Annotation annotation)

Identifies the proper conversion for a given Field and an annotation from the package com.univocity.parsers.annotations

Parameters:

target - The field or method to have conversions applied to

annotation - the annotation from com.univocity.parsers.annotations that identifies a Conversion instance.

Returns:

The Conversion that should be applied to the field

getConversion

public static Conversion getConversion(Class classType,
                                       Annotation annotation)

Identifies the proper conversion for a given type and an annotation from the package com.univocity.parsers.annotations

Parameters:

classType - the type to have conversions applied to

annotation - the annotation from com.univocity.parsers.annotations that identifies a Conversion instance.

Returns:

The Conversion that should be applied to the type

newInstance

public static <T> T newInstance(Class parent,
                                Class<T> type,
                                String[] args)

getDefaultConversion

public static Conversion getDefaultConversion(Class fieldType,
                                              Parsed parsed)

Identifies the proper conversion for a given type

Parameters:

fieldType - The type of field to have conversions applied to.

parsed - the Parsed annotation from com.univocity.parsers.annotations.

Returns:

The Conversion that should be applied to the field type

getDefaultConversion

public static Conversion getDefaultConversion(AnnotatedElement target)

Returns the default Conversion that should be applied to the field based on its type.

Parameters:

target - The field or method whose values must be converted from a given parsed String.

Returns:

The default Conversion applied to the given field.

applyFormatSettings

public static void applyFormatSettings(Object formatter,
                                       String[] propertiesAndValues)

Applied the configuration of a formatter object (SimpleDateFormat, NumberFormat and others).

Parameters:

formatter - the formatter instance

propertiesAndValues - a sequence of key-value pairs, where the key is a property of the formatter object to be set to the following value via reflection

allFieldsIndexBasedForParsing

public static boolean allFieldsIndexBasedForParsing(Class<?> beanClass)

Runs through all annotations of a given class to identify whether all annotated fields and methods (with the Parsed annotation) are mapped to a column by index.

Parameters:

beanClass - a class whose Parsed annotations will be processed.

Returns:

true if every field and method annotated with Parsed in the given class maps to an index, otherwise false.

allFieldsNameBasedForParsing

public static boolean allFieldsNameBasedForParsing(Class<?> beanClass)

Runs through all annotations of a given class to identify whether all annotated fields and methods (with the Parsed annotation) are mapped to a column by name.

Parameters:

beanClass - a class whose Parsed annotations will be processed.

Returns:

true if every field and method annotated with Parsed in the given class maps to a header name, otherwise false.

allFieldsIndexBasedForWriting

public static boolean allFieldsIndexBasedForWriting(Class<?> beanClass)

Runs through all annotations of a given class to identify whether all annotated fields and methods (with the Parsed annotation) are mapped to a column by index.

Parameters:

beanClass - a class whose Parsed annotations will be processed.

Returns:

true if every field and method annotated with Parsed in the given class maps to an index, otherwise false.

allFieldsNameBasedForWriting

public static boolean allFieldsNameBasedForWriting(Class<?> beanClass)

Runs through all annotations of a given class to identify whether all annotated fields and methods (with the Parsed annotation) are mapped to a column by name.

Parameters:

beanClass - a class whose Parsed annotations will be processed.

Returns:

true if every field and method annotated with Parsed in the given class maps to a header name, otherwise false.

getSelectedIndexes

public static Integer[] getSelectedIndexes(Class<?> beanClass,
                                           MethodFilter filter)

Runs through all Parsed annotations of a given class to identify all indexes associated with its fields

Parameters:

beanClass - a class whose Parsed annotations will be processed.

filter - filter to apply over annotated methods when the class is being used for reading data from beans (to write values to an output) or when writing values into beans (while parsing). It is used to choose either a "get" or a "set" method annotated with Parsed, when both methods target the same field.

Returns:

an array of column indexes used by the given class

deriveHeaderNamesFromFields

public static String[] deriveHeaderNamesFromFields(Class<?> beanClass,
                                                   MethodFilter filter)

Runs through all Parsed annotations of a given class to identify all header names associated with its fields

Parameters:

beanClass - a class whose Parsed annotations will be processed.

filter - a filter to exclude annotated methods that won't be used for parsing or writing

Returns:

an array of column names used by the given class

findHeadersAnnotation

public static Headers findHeadersAnnotation(Class<?> beanClass)

Searches for the Headers annotation in the hierarchy of a class

Parameters:

beanClass - the class whose hierarchy will be searched

Returns:

the Headers annotation of the given class or its most immediate parent, or null if not found.

getType

public static Class<?> getType(AnnotatedElement element)

getDeclaringClass

public static Class<?> getDeclaringClass(AnnotatedElement element)

getName

public static String getName(AnnotatedElement element)

getFieldSequence

public static List<TransformedHeader> getFieldSequence(Class beanClass,
                                                       boolean processNested,
                                                       HeaderTransformer transformer,
                                                       MethodFilter filter)

Returns a list of fields with Parsed annotations in the sequence they should be processed for parsing or writing. The sequence is ordered taking into account their original order in the annotated class, unless Parsed.index() is set to a non-negative number.

Parameters:

beanClass - the class whose field sequence will be returned.

processNested - flag indicating whether Nested annotations should be processed

transformer - a HeaderTransformer instance to be used for transforming headers of a given Nested attribute.

filter - filter to apply over annotated methods when the class is being used for reading data from beans (to write values to an output) or when writing values into beans (while parsing). It is used to choose either a "get" or a "set" method annotated with Parsed, when both methods target the same field.

Returns:

a list of fields ordered by their processing sequence

getAllFields

public static Map<Field,PropertyWrapper> getAllFields(Class<?> beanClass)

Returns all fields available from a given class.

Parameters:

beanClass - a class whose fields will be returned.

Returns:

a map of Field and the corresponding PropertyWrapper

getAnnotatedMethods

public static List<Method> getAnnotatedMethods(Class<?> beanClass,
                                               MethodFilter filter)

Returns all methods available from a given class that have an annotation.

Parameters:

beanClass - a class whose methods will be returned.

filter - filter to apply over annotated methods when the class is being used for reading data from beans (to write values to an output) or when writing values into beans (while parsing). It is used to choose either a "get" or a "set" method annotated with Parsed, when both methods target the same field.

Returns:

a map of Method and the corresponding PropertyWrapper

findAnnotation

public static <A extends Annotation> A findAnnotation(AnnotatedElement annotatedElement,
                                                      Class<A> annotationType)

Searches for an annotation of a given type that's been applied to an element either directly (as a regular annotation) or indirectly (as a meta-annotations, i.e. an annotation that has annotations).

Type Parameters:

A - the type of the annotation being searched for

Parameters:

annotatedElement - the element whose annotations will be searched

annotationType - the type of annotation to search for

Returns:

the annotation associated with the given element, or null if not found.

findAllAnnotationsInPackage

public static List<Annotation> findAllAnnotationsInPackage(AnnotatedElement annotatedElement,
                                                           Package aPackage)

Returns all annotations applied to an element, excluding the ones not in a given package.

Parameters:

annotatedElement - the element (method, field, etc) whose annotations will be extracted

aPackage - the package of the annotations that should be returned

Returns:

the list of annotation elements applied to the given element, that are also members of the given package.

getDefaultPrimitiveValue

public static final Object getDefaultPrimitiveValue(Class type)

Returns Java's default value for a given type, in a primitive type wrapper.

Parameters:

type - the primitive type whose default value will be returned.

Returns:

the default value for the given primitive type, or null if the type is not primitive.