Package 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

  • Field Details

    • lastProcessedElement

      private static AnnotatedElement lastProcessedElement

    • lastProcessedAnnotationType

      private static Class<? extends Annotation> lastProcessedAnnotationType

    • lastAnnotationFound

      private static Annotation lastAnnotationFound

    • javaLangAnnotationTypes

      private static final Set<Class> javaLangAnnotationTypes

    • customAnnotationTypes

      private static final Set<Class> customAnnotationTypes

  • Constructor Details

    • AnnotationHelper

      private AnnotationHelper()

  • Method Details

    • getNullValue

      private static String getNullValue(String defaultValue)
      Converts the special "null" strings that might be provided by and Parsed#defaultNullWrite()
      Parameters:
      defaultValue - The string returned by and Parsed#defaultNullWrite()
      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.

    • getNullWriteValue

      public static String getNullWriteValue(AnnotatedElement target, Parsed parsed)

    • getNullReadValue

      public static String getNullReadValue(AnnotatedElement target, Parsed parsed)

    • 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

    • createDefaultEnumConversion

      public static EnumConversion createDefaultEnumConversion(Class fieldType, String nullRead, String nullWrite)

    • getConversion

      public static Conversion getConversion(Class fieldType, AnnotatedElement target, Annotation annotation, String nullRead, String nullWrite)

    • extractOption

      private static String extractOption(String[] options, String key)

    • extractTimeZone

      private static TimeZone extractTimeZone(String[] options)

    • extractLocale

      private static Locale extractLocale(String[] options)

    • newInstance

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

    • getDefaultConversion

      public static Conversion getDefaultConversion(Class fieldType, AnnotatedElement target, Parsed parsed)
      Identifies the proper conversion for a given type
      Parameters:
      fieldType - The type of field to have conversions applied to.
      target - the annotated attribute of method that has the annotation
      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

    • invokeSetter

      private static void invokeSetter(Object formatter, PropertyWrapper property, String value)

    • allFieldsIndexOrNameBased

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

    • 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

    • findAnnotationInClass

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

    • 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)

    • describeElement

      static String describeElement(AnnotatedElement element)

    • processAnnotations

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

    • 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

    • getFieldSequence

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

    • 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 <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.
      Type Parameters:
      A - the expected annotation type
      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.
      annotationType - the annotation type to consider
      Returns:
      a list of Method with at least one annotation

    • getAllMethods

      public static List<Method> getAllMethods(Class<?> beanClass, MethodFilter filter)
      Returns all methods available from a given class
      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 list of Methods that conform to the given filter.

    • 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 list of Method with at least one annotation

    • getAnnotatedFields

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

    • getAnnotatedFields

      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.
      Type Parameters:
      A - the expected annotation type
      Parameters:
      beanClass - a class whose methods will be returned.
      annotationType - the type of annotation to consider
      Returns:
      a list of Field with at least one annotation

    • 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.

    • findAnnotationMethodType

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

    • invoke

      private static Object invoke(Annotation annotation, Method method)

    • findAnnotation

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

    • isCustomAnnotation

      private static boolean isCustomAnnotation(Annotation annotation)

    • 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.

    • findAllAnnotationsInPackage

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

    • 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.