univocity-parsers 2.9.1 · com.univocity.parsers.annotations.helpers.AnnotationHelper

Modifier and Type	Class and Description
private static class	AnnotationHelper.NO_ANNOTATIONS

Modifier and Type	Field and Description
private static final Set<Class<T>>	customAnnotationTypes
private static final Set<Class<T>>	javaLangAnnotationTypes
private static Annotation	lastAnnotationFound
private static Class<? extends Annotation>	lastProcessedAnnotationType
private static AnnotatedElement	lastProcessedElement

Access	Constructor and Description
private	AnnotationHelper()

Method Summary

Modifier and Type	Method and Description
public static boolean	Returns: `true` if every field and method annotated with `Parsed` in the given class maps to an index, otherwise `false`. allFieldsIndexBasedForParsing(Class<?> a class whose `Parsed` annotations will be processed. 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.
public static boolean	Returns: `true` if every field and method annotated with `Parsed` in the given class maps to an index, otherwise `false`. allFieldsIndexBasedForWriting(Class<?> a class whose `Parsed` annotations will be processed. 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.
private static boolean	allFieldsIndexOrNameBased(boolean searchName, Class<?> beanClass, MethodFilter filter)
public static boolean	Returns: `true` if every field and method annotated with `Parsed` in the given class maps to a header name, otherwise `false`. allFieldsNameBasedForParsing(Class<?> a class whose `Parsed` annotations will be processed. 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.
public static boolean	Returns: `true` if every field and method annotated with `Parsed` in the given class maps to a header name, otherwise `false`. allFieldsNameBasedForWriting(Class<?> a class whose `Parsed` annotations will be processed. 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.
public static void	applyFormatSettings(Object the formatter instance formatter, String[] 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 propertiesAndValues) Applied the configuration of a formatter object (`SimpleDateFormat`, `NumberFormat` and others).
public static EnumConversion<T extends Enum<T>>	createDefaultEnumConversion(Class<T> fieldType, String nullRead, String nullWrite)
public static String[]	Returns: an array of column names used by the given class deriveHeaderNamesFromFields(Class<?> a class whose `Parsed` annotations will be processed. beanClass, MethodFilter a filter to exclude annotated methods that won't be used for parsing or writing filter) Runs through all `Parsed` annotations of a given class to identify all header names associated with its fields
pack-priv static String	describeElement(AnnotatedElement element)
private static Locale	extractLocale(String[] options)
private static String	extractOption(String[] options, String key)
private static TimeZone	extractTimeZone(String[] options)
public static List<Annotation>	Returns: the list of annotation elements applied to the given element, that are also members of the given package. findAllAnnotationsInPackage(AnnotatedElement the element (method, field, etc) whose annotations will be extracted annotatedElement, Package the package of the annotations that should be returned aPackage) Returns all annotations applied to an element, excluding the ones not in a given package.
private static void	findAllAnnotationsInPackage(AnnotatedElement annotatedElement, Package aPackage, ArrayList<? super Annotation> found, Set<Annotation> visited)
public static synchronized < the type of the annotation being searched for A extends Annotation> A	Returns: the annotation associated with the given element, or `null` if not found. findAnnotation(AnnotatedElement the element whose annotations will be searched annotatedElement, Class<A> the type of annotation to search for 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).
private static <A> A	findAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType, Set<Annotation> visited, Stack<Annotation> path)
public static < the type of the annotation to return T extends Annotation> T	Returns: the annotation of the given class or its most immediate parent, or `null` if not found. findAnnotationInClass(Class<?> the class whose hierarchy will be searched beanClass, Class<T> the annotation to locate annotation) Searches for a given annotation in the hierarchy of a class
private static Class<?>	findAnnotationMethodType(Class<? extends Annotation> type, String methodName)
public static Headers	Returns: the `Headers` annotation of the given class or its most immediate parent, or `null` if not found. findHeadersAnnotation(Class<?> the class whose hierarchy will be searched beanClass) Searches for the `Headers` annotation in the hierarchy of a class
public static Map<Field, PropertyWrapper>	Returns: a map of `Field` and the corresponding `PropertyWrapper` getAllFields(Class<?> a class whose fields will be returned. beanClass) Returns all fields available from a given class.
public static List<Method>	Returns: a list of `Method`s that conform to the given filter. getAllMethods(Class<?> a class whose methods will be returned. beanClass, MethodFilter 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. filter) Returns all methods available from a given class
public static List<Field>	Returns: a list of `Field` with at least one annotation getAnnotatedFields(Class<?> a class whose methods will be returned. beanClass) Returns all attributes available from a given class that have an annotation.
public static < the expected annotation type A extends Annotation> List<Field>	Returns: a list of `Field` with at least one annotation getAnnotatedFields(Class<?> a class whose methods will be returned. beanClass, Class<A> the type of annotation to consider annotationType) Returns all attributes available from a given class that have an annotation.
public static < the expected annotation type A extends Annotation> List<Method>	Returns: a list of `Method` with at least one annotation getAnnotatedMethods(Class<?> a class whose methods will be returned. beanClass, MethodFilter 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. filter, Class<A> the annotation type to consider annotationType) Returns all methods available from a given class that have a specific annotation.
public static List<Method>	Returns: a list of `Method` with at least one annotation getAnnotatedMethods(Class<?> a class whose methods will be returned. beanClass, MethodFilter 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. filter) Returns all methods available from a given class that have an annotation.
public static Conversion<I, O>	Returns: The `Conversion` that should be applied to the type getConversion(Class<T> the type to have conversions applied to classType, Annotation the annotation from `com.univocity.parsers.annotations` that identifies a `Conversion` instance. annotation) Identifies the proper conversion for a given type and an annotation from the package `com.univocity.parsers.annotations`
public static Conversion<I, O>	getConversion(Class<T> fieldType, AnnotatedElement target, Annotation annotation, String nullRead, String nullWrite)
public static Class<?>	getDeclaringClass(AnnotatedElement element)
public static Conversion<I, O>	Returns: The `Conversion` that should be applied to the field type getDefaultConversion(Class<T> The type of field to have conversions applied to. fieldType, AnnotatedElement the annotated attribute of method that has the annotation target, Parsed the `Parsed` annotation from `com.univocity.parsers.annotations`. parsed) Identifies the proper conversion for a given type
public static Conversion<I, O>	Returns: The default `Conversion` applied to the given field. getDefaultConversion(AnnotatedElement The field or method whose values must be converted from a given parsed String. target) Returns the default `Conversion` that should be applied to the field based on its type.
public static final Object	Returns: the default value for the given primitive type, or `null` if the type is not primitive. getDefaultPrimitiveValue(Class<T> the primitive type whose default value will be returned. type) Returns Java's default value for a given type, in a primitive type wrapper.
public static List<TransformedHeader>	Returns: a list of fields ordered by their processing sequence getFieldSequence(Class<T> the class whose field sequence will be returned. beanClass, boolean flag indicating whether `Nested` annotations should be processed processNested, HeaderTransformer a `HeaderTransformer` instance to be used for transforming headers of a given `Nested` attribute. transformer, MethodFilter 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. filter) Returns a list of fields with `Parsed` annotations in the sequence they should be processed for parsing or writing.
private static List<TransformedHeader>	getFieldSequence(Class<T> beanClass, boolean processNested, List<Integer> indexes, HeaderTransformer transformer, MethodFilter filter)
public static String	getName(AnnotatedElement element)
public static String	getNullReadValue(AnnotatedElement target, Parsed parsed)
private static String	Returns: the default value if it is not the String literal "null" or "'null'". If "null" was provided, then null will be returned. If "'null'" was provided, then "null" will be returned. getNullValue(String The string returned by `and Parsed#defaultNullWrite()` defaultValue) Converts the special "null" strings that might be provided by `and Parsed#defaultNullWrite()`
public static String	getNullWriteValue(AnnotatedElement target, Parsed parsed)
public static Integer[]	Returns: an array of column indexes used by the given class getSelectedIndexes(Class<?> a class whose `Parsed` annotations will be processed. beanClass, MethodFilter 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. filter) Runs through all `Parsed` annotations of a given class to identify all indexes associated with its fields
public static Class<?>	getType(AnnotatedElement element)
private static Object	invoke(Annotation annotation, Method method)
private static void	invokeSetter(Object formatter, PropertyWrapper property, final String value)
private static boolean	isCustomAnnotation(Annotation annotation)
public static <T> T	newInstance(Class<T> parent, Class<T> type, String[] args)
private static void	processAnnotations(AnnotatedElement element, boolean processNested, List<Integer> indexes, List<TransformedHeader> tmp, Map<AnnotatedElement, List<TransformedHeader>> nestedReplacements, HeaderTransformer transformer, MethodFilter filter)

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

customAnnotationTypes	back to summary
private static final Set<Class<T>> customAnnotationTypes

javaLangAnnotationTypes	back to summary
private static final Set<Class<T>> javaLangAnnotationTypes

lastAnnotationFound	back to summary
private static Annotation lastAnnotationFound

lastProcessedAnnotationType	back to summary
private static Class<? extends Annotation> lastProcessedAnnotationType

lastProcessedElement	back to summary
private static AnnotatedElement lastProcessedElement

AnnotationHelper	back to summary
private AnnotationHelper()

Method Detail

allFieldsIndexBasedForParsing back to summary

allFieldsIndexBasedForParsing	back to summary
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:Class<?> a class whose `Parsed` annotations will be processed. Returns:boolean `true` if every field and method annotated with `Parsed` in the given class maps to an index, otherwise `false`.

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:Class<?>: a class whose Parsed annotations will be processed.

Returns:boolean

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

allFieldsIndexBasedForWriting back to summary

allFieldsIndexBasedForWriting	back to summary
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:Class<?> a class whose `Parsed` annotations will be processed. Returns:boolean `true` if every field and method annotated with `Parsed` in the given class maps to an index, otherwise `false`.

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:Class<?>: a class whose Parsed annotations will be processed.

Returns:boolean

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

allFieldsIndexOrNameBased	back to summary
private static boolean allFieldsIndexOrNameBased(boolean searchName, Class<?> beanClass, MethodFilter filter)

allFieldsNameBasedForParsing back to summary

allFieldsNameBasedForParsing	back to summary
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:Class<?> a class whose `Parsed` annotations will be processed. Returns:boolean `true` if every field and method annotated with `Parsed` in the given class maps to a header name, otherwise `false`.

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:Class<?>: a class whose Parsed annotations will be processed.

Returns:boolean

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

allFieldsNameBasedForWriting back to summary

allFieldsNameBasedForWriting	back to summary
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:Class<?> a class whose `Parsed` annotations will be processed. Returns:boolean `true` if every field and method annotated with `Parsed` in the given class maps to a header name, otherwise `false`.

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:Class<?>: a class whose Parsed annotations will be processed.

Returns:boolean

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

applyFormatSettings back to summary

applyFormatSettings	back to summary
public static void applyFormatSettings(Object formatter, String[] propertiesAndValues) Applied the configuration of a formatter object (`SimpleDateFormat`, `NumberFormat` and others). Parameters formatter:Object the formatter instance propertiesAndValues:String[] 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

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

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

Parameters

formatter:Object: the formatter instance
propertiesAndValues:String[]: 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

createDefaultEnumConversion	back to summary
public static EnumConversion<T extends Enum<T>> createDefaultEnumConversion(Class<T> fieldType, String nullRead, String nullWrite)

deriveHeaderNamesFromFields back to summary

deriveHeaderNamesFromFields	back to summary
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:Class<?> a class whose `Parsed` annotations will be processed. filter:MethodFilter a filter to exclude annotated methods that won't be used for parsing or writing Returns:String[] an array of column names used by the given class

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:Class<?>: a class whose Parsed annotations will be processed.
filter:MethodFilter: a filter to exclude annotated methods that won't be used for parsing or writing

Returns:String[]

an array of column names used by the given class

describeElement	back to summary
pack-priv static String describeElement(AnnotatedElement element)

extractLocale	back to summary
private static Locale extractLocale(String[] options)

extractOption	back to summary
private static String extractOption(String[] options, String key)

extractTimeZone	back to summary
private static TimeZone extractTimeZone(String[] options)

findAllAnnotationsInPackage	back to summary
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:AnnotatedElement the element (method, field, etc) whose annotations will be extracted aPackage:Package the package of the annotations that should be returned Returns:List<Annotation> the list of annotation elements applied to the given element, that are also members of the given package.

findAllAnnotationsInPackage

back to summary

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:AnnotatedElement: the element (method, field, etc) whose annotations will be extracted
aPackage:Package: the package of the annotations that should be returned

Returns:List<Annotation>

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

findAllAnnotationsInPackage	back to summary
private static void findAllAnnotationsInPackage(AnnotatedElement annotatedElement, Package aPackage, ArrayList<? super Annotation> found, Set<Annotation> visited)

findAnnotation back to summary

findAnnotation	back to summary
public static synchronized <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). Parameters <A> the type of the annotation being searched for annotatedElement:AnnotatedElement the element whose annotations will be searched annotationType:Class<A> the type of annotation to search for Returns:A the annotation associated with the given element, or `null` if not found.

public static synchronized <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).

Parameters

<A>: the type of the annotation being searched for
annotatedElement:AnnotatedElement: the element whose annotations will be searched
annotationType:Class<A>: the type of annotation to search for

Returns:A

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

findAnnotation	back to summary
private static <A> A findAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType, Set<Annotation> visited, Stack<Annotation> path)

findAnnotationInClass back to summary

findAnnotationInClass	back to summary
public static <T extends Annotation> T findAnnotationInClass(Class<?> beanClass, Class<T> annotation) Searches for a given annotation in the hierarchy of a class Parameters <T> the type of the annotation to return beanClass:Class<?> the class whose hierarchy will be searched annotation:Class<T> the annotation to locate Returns:T the annotation of the given class or its most immediate parent, or `null` if not found.

public static <T extends Annotation> T findAnnotationInClass(Class<?> beanClass, Class<T> annotation)

Searches for a given annotation in the hierarchy of a class

Parameters

<T>: the type of the annotation to return
beanClass:Class<?>: the class whose hierarchy will be searched
annotation:Class<T>: the annotation to locate

Returns:T

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

findAnnotationMethodType	back to summary
private static Class<?> findAnnotationMethodType(Class<? extends Annotation> type, String methodName)

findHeadersAnnotation back to summary

findHeadersAnnotation	back to summary
public static Headers findHeadersAnnotation(Class<?> beanClass) Searches for the `Headers` annotation in the hierarchy of a class Parameters beanClass:Class<?> the class whose hierarchy will be searched Returns:Headers the `Headers` annotation of the given class or its most immediate parent, or `null` if not found.

public static Headers findHeadersAnnotation(Class<?> beanClass)

Searches for the Headers annotation in the hierarchy of a class

Parameters

beanClass:Class<?>: the class whose hierarchy will be searched

Returns:Headers

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

getAllFields back to summary

getAllFields	back to summary
public static Map<Field, PropertyWrapper> getAllFields(Class<?> beanClass) Returns all fields available from a given class. Parameters beanClass:Class<?> a class whose fields will be returned. Returns:Map<Field, PropertyWrapper> a map of `Field` and the corresponding `PropertyWrapper`

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

Returns all fields available from a given class.

Parameters

beanClass:Class<?>: a class whose fields will be returned.

Returns:Map<Field, PropertyWrapper>

a map of Field and the corresponding PropertyWrapper

getAllMethods back to summary

getAllMethods	back to summary
public static List<Method> getAllMethods(Class<?> beanClass, MethodFilter filter) Returns all methods available from a given class Parameters beanClass:Class<?> a class whose methods will be returned. filter:MethodFilter 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:List<Method> a list of `Method`s that conform to the given filter.

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

Returns all methods available from a given class

Parameters

beanClass:Class<?>: a class whose methods will be returned.
filter:MethodFilter: 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:List<Method>

a list of Methods that conform to the given filter.

getAnnotatedFields back to summary

getAnnotatedFields	back to summary
public static List<Field> getAnnotatedFields(Class<?> beanClass) Returns all attributes available from a given class that have an annotation. Parameters beanClass:Class<?> a class whose methods will be returned. Returns:List<Field> a list of `Field` with at least one annotation

public static List<Field> getAnnotatedFields(Class<?> beanClass)

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

Parameters

beanClass:Class<?>: a class whose methods will be returned.

Returns:List<Field>

a list of Field with at least one annotation

getAnnotatedFields back to summary

getAnnotatedFields	back to summary
public static <A extends Annotation> List<Field> getAnnotatedFields(Class<?> beanClass, Class<A> annotationType) Returns all attributes available from a given class that have an annotation. Parameters <A> the expected annotation type beanClass:Class<?> a class whose methods will be returned. annotationType:Class<A> the type of annotation to consider Returns:List<Field> a list of `Field` with at least one annotation

public static <A extends Annotation> List<Field> getAnnotatedFields(Class<?> beanClass, Class<A> annotationType)

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

Parameters

<A>: the expected annotation type
beanClass:Class<?>: a class whose methods will be returned.
annotationType:Class<A>: the type of annotation to consider

Returns:List<Field>

a list of Field with at least one annotation

getAnnotatedMethods back to summary

getAnnotatedMethods	back to summary
public static <A extends Annotation> List<Method> getAnnotatedMethods(Class<?> beanClass, MethodFilter filter, Class<A> annotationType) Returns all methods available from a given class that have a specific annotation. Parameters <A> the expected annotation type beanClass:Class<?> a class whose methods will be returned. filter:MethodFilter 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. annotationType:Class<A> the annotation type to consider Returns:List<Method> a list of `Method` with at least one annotation

public static <A extends Annotation> List<Method> getAnnotatedMethods(Class<?> beanClass, MethodFilter filter, Class<A> annotationType)

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

Parameters

<A>: the expected annotation type
beanClass:Class<?>: a class whose methods will be returned.
filter:MethodFilter: 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.
annotationType:Class<A>: the annotation type to consider

Returns:List<Method>

a list of Method with at least one annotation

getAnnotatedMethods back to summary

getAnnotatedMethods	back to summary
public static List<Method> getAnnotatedMethods(Class<?> beanClass, MethodFilter filter) Returns all methods available from a given class that have an annotation. Parameters beanClass:Class<?> a class whose methods will be returned. filter:MethodFilter 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:List<Method> a list of `Method` with at least one annotation

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

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

Parameters

beanClass:Class<?>: a class whose methods will be returned.
filter:MethodFilter: 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:List<Method>

a list of Method with at least one annotation

getConversion back to summary

getConversion	back to summary
public static Conversion<I, O> getConversion(Class<T> classType, Annotation annotation) Identifies the proper conversion for a given type and an annotation from the package `com.univocity.parsers.annotations` Parameters classType:Class<T> the type to have conversions applied to annotation:Annotation the annotation from `com.univocity.parsers.annotations` that identifies a `Conversion` instance. Returns:Conversion<I, O> The `Conversion` that should be applied to the type Annotations @SuppressWarnings:rawtypes

public static Conversion<I, O> getConversion(Class<T> classType, Annotation annotation)

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

Parameters

classType:Class<T>: the type to have conversions applied to
annotation:Annotation: the annotation from com.univocity.parsers.annotations that identifies a Conversion instance.

Returns:Conversion<I, O>

The Conversion that should be applied to the type

Annotations

@SuppressWarnings:rawtypes

getConversion	back to summary
public static Conversion<I, O> getConversion(Class<T> fieldType, AnnotatedElement target, Annotation annotation, String nullRead, String nullWrite) Annotations @SuppressWarnings:rawtypes, unchecked

getDeclaringClass	back to summary
public static Class<?> getDeclaringClass(AnnotatedElement element)

getDefaultConversion back to summary

getDefaultConversion	back to summary
public static Conversion<I, O> getDefaultConversion(Class<T> fieldType, AnnotatedElement target, Parsed parsed) Identifies the proper conversion for a given type Parameters fieldType:Class<T> The type of field to have conversions applied to. target:AnnotatedElement the annotated attribute of method that has the annotation parsed:Parsed the `Parsed` annotation from `com.univocity.parsers.annotations`. Returns:Conversion<I, O> The `Conversion` that should be applied to the field type Annotations @SuppressWarnings:rawtypes, unchecked

public static Conversion<I, O> getDefaultConversion(Class<T> fieldType, AnnotatedElement target, Parsed parsed)

Identifies the proper conversion for a given type

Parameters

fieldType:Class<T>: The type of field to have conversions applied to.
target:AnnotatedElement: the annotated attribute of method that has the annotation
parsed:Parsed: the Parsed annotation from com.univocity.parsers.annotations.

Returns:Conversion<I, O>

The Conversion that should be applied to the field type

Annotations

@SuppressWarnings:rawtypes, unchecked

getDefaultConversion back to summary

getDefaultConversion	back to summary
public static Conversion<I, O> getDefaultConversion(AnnotatedElement target) Returns the default `Conversion` that should be applied to the field based on its type. Parameters target:AnnotatedElement The field or method whose values must be converted from a given parsed String. Returns:Conversion<I, O> The default `Conversion` applied to the given field. Annotations @SuppressWarnings:rawtypes

public static Conversion<I, O> getDefaultConversion(AnnotatedElement target)

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

Parameters

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

Returns:Conversion<I, O>

The default Conversion applied to the given field.

Annotations

@SuppressWarnings:rawtypes

getDefaultPrimitiveValue back to summary

getDefaultPrimitiveValue	back to summary
public static final Object getDefaultPrimitiveValue(Class<T> type) Returns Java's default value for a given type, in a primitive type wrapper. Parameters type:Class<T> the primitive type whose default value will be returned. Returns:Object the default value for the given primitive type, or `null` if the type is not primitive.

public static final Object getDefaultPrimitiveValue(Class<T> type)

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

Parameters

type:Class<T>: the primitive type whose default value will be returned.

Returns:Object

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

getFieldSequence back to summary

getFieldSequence	back to summary
public static List<TransformedHeader> getFieldSequence(Class<T> 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:Class<T> the class whose field sequence will be returned. processNested:boolean flag indicating whether `Nested` annotations should be processed transformer:HeaderTransformer a `HeaderTransformer` instance to be used for transforming headers of a given `Nested` attribute. filter:MethodFilter 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:List<TransformedHeader> a list of fields ordered by their processing sequence

public static List<TransformedHeader> getFieldSequence(Class<T> 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:Class<T>: the class whose field sequence will be returned.
processNested:boolean: flag indicating whether Nested annotations should be processed
transformer:HeaderTransformer: a HeaderTransformer instance to be used for transforming headers of a given Nested attribute.
filter:MethodFilter: 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:List<TransformedHeader>

a list of fields ordered by their processing sequence

getFieldSequence	back to summary
private static List<TransformedHeader> getFieldSequence(Class<T> beanClass, boolean processNested, List<Integer> indexes, HeaderTransformer transformer, MethodFilter filter)

getName	back to summary
public static String getName(AnnotatedElement element)

getNullReadValue	back to summary
public static String getNullReadValue(AnnotatedElement target, Parsed parsed)

getNullValue back to summary

getNullValue	back to summary
private static String getNullValue(String defaultValue) Converts the special "null" strings that might be provided by `and Parsed#defaultNullWrite()` Parameters defaultValue:String The string returned by `and Parsed#defaultNullWrite()` Returns:String the default value if it is not the String literal "null" or "'null'". If "null" was provided, then null will be returned. If "'null'" was provided, then "null" will be returned.

private static String getNullValue(String defaultValue)

Converts the special "null" strings that might be provided by and Parsed#defaultNullWrite()

Parameters

defaultValue:String: The string returned by and Parsed#defaultNullWrite()

Returns:String

the default value if it is not the String literal "null" or "'null'".

If "null" was provided, then null will be returned.

If "'null'" was provided, then "null" will be returned.

getNullWriteValue	back to summary
public static String getNullWriteValue(AnnotatedElement target, Parsed parsed)

getSelectedIndexes back to summary

getSelectedIndexes	back to summary
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:Class<?> a class whose `Parsed` annotations will be processed. filter:MethodFilter 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:Integer[] an array of column indexes used by the given class

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:Class<?>: a class whose Parsed annotations will be processed.
filter:MethodFilter: 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:Integer[]

an array of column indexes used by the given class

getType	back to summary
public static Class<?> getType(AnnotatedElement element)

invoke	back to summary
private static Object invoke(Annotation annotation, Method method)

invokeSetter	back to summary
private static void invokeSetter(Object formatter, PropertyWrapper property, final String value)

isCustomAnnotation	back to summary
private static boolean isCustomAnnotation(Annotation annotation)

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

processAnnotations	back to summary
private static void processAnnotations(AnnotatedElement element, boolean processNested, List<Integer> indexes, List<TransformedHeader> tmp, Map<AnnotatedElement, List<TransformedHeader>> nestedReplacements, HeaderTransformer transformer, MethodFilter filter)

public Class AnnotationHelper

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private final Class AnnotationHelper.NO_ANNOTATIONS

Constructor Summary

Method Summary

Constructor Detail

Method Detail