Package com.univocity.parsers.annotations.helpers

Class AnnotationHelper

  • public class AnnotationHelper
extends java.lang.Object
    Helper class to process fields annotated with Parsed
    Author:
    uniVocity Software Pty Ltd - parsers@univocity.com

    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      static boolean allFieldsIndexBasedForParsing​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.Object formatter, java.lang.String[] propertiesAndValues)
      Applied the configuration of a formatter object (SimpleDateFormat, NumberFormat and others).
      static java.lang.String[] deriveHeaderNamesFromFields​(java.lang.Class<?> beanClass, MethodFilter filter)
      Runs through all Parsed annotations of a given class to identify all header names associated with its fields
      static java.util.List<java.lang.annotation.Annotation> findAllAnnotationsInPackage​(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.Package aPackage)
      Returns all annotations applied to an element, excluding the ones not in a given package.
      static <A extends java.lang.annotation.Annotation>
      A      		 findAnnotation​(java.lang.reflect.AnnotatedElement annotatedElement, java.lang.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​(java.lang.Class<?> beanClass)
      Searches for the Headers annotation in the hierarchy of a class
      static java.util.Map<java.lang.reflect.Field,​PropertyWrapper> getAllFields​(java.lang.Class<?> beanClass)
      Returns all fields available from a given class.
      static java.util.List<java.lang.reflect.Method> getAnnotatedMethods​(java.lang.Class<?> beanClass, MethodFilter filter)
      Returns all methods available from a given class that have an annotation.
      static Conversion getConversion​(java.lang.Class classType, java.lang.annotation.Annotation annotation)
      Identifies the proper conversion for a given type and an annotation from the package com.univocity.parsers.annotations
      static Conversion getConversion​(java.lang.reflect.AnnotatedElement target, java.lang.annotation.Annotation annotation)
      Identifies the proper conversion for a given Field and an annotation from the package com.univocity.parsers.annotations
      static java.lang.Class<?> getDeclaringClass​(java.lang.reflect.AnnotatedElement element)  
      static Conversion getDefaultConversion​(java.lang.Class fieldType, Parsed parsed)
      Identifies the proper conversion for a given type
      static Conversion getDefaultConversion​(java.lang.reflect.AnnotatedElement target)
      Returns the default Conversion that should be applied to the field based on its type.
      static java.lang.Object getDefaultPrimitiveValue​(java.lang.Class type)
      Returns Java's default value for a given type, in a primitive type wrapper.
      static java.util.List<TransformedHeader> getFieldSequence​(java.lang.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 java.lang.String getName​(java.lang.reflect.AnnotatedElement element)  
      static java.lang.Integer[] getSelectedIndexes​(java.lang.Class<?> beanClass, MethodFilter filter)
      Runs through all Parsed annotations of a given class to identify all indexes associated with its fields
      static java.lang.Class<?> getType​(java.lang.reflect.AnnotatedElement element)  
      static <T> T newInstance​(java.lang.Class parent, java.lang.Class<T> type, java.lang.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​(java.lang.reflect.AnnotatedElement target,
                                       java.lang.annotation.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​(java.lang.Class classType,
                                       java.lang.annotation.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​(java.lang.Class parent,
                                java.lang.Class<T> type,
                                java.lang.String[] args)

      • getDefaultConversion

        public static Conversion getDefaultConversion​(java.lang.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​(java.lang.reflect.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​(java.lang.Object formatter,
                                       java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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 java.lang.Integer[] getSelectedIndexes​(java.lang.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 java.lang.String[] deriveHeaderNamesFromFields​(java.lang.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​(java.lang.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 java.lang.Class<?> getType​(java.lang.reflect.AnnotatedElement element)

      • getDeclaringClass

        public static java.lang.Class<?> getDeclaringClass​(java.lang.reflect.AnnotatedElement element)

      • getName

        public static java.lang.String getName​(java.lang.reflect.AnnotatedElement element)

      • getFieldSequence

        public static java.util.List<TransformedHeader> getFieldSequence​(java.lang.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 java.util.Map<java.lang.reflect.Field,​PropertyWrapper> getAllFields​(java.lang.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 java.util.List<java.lang.reflect.Method> getAnnotatedMethods​(java.lang.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 java.lang.annotation.Annotation> A findAnnotation​(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                           java.lang.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 java.util.List<java.lang.annotation.Annotation> findAllAnnotationsInPackage​(java.lang.reflect.AnnotatedElement annotatedElement,
                                                                                          java.lang.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 java.lang.Object getDefaultPrimitiveValue​(java.lang.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.