Module org.refcodes.struct
Package org.refcodes.struct

Enum SimpleType

  • All Implemented Interfaces:
    Serializable, Comparable<SimpleType>
    public enum SimpleType
extends Enum<SimpleType>
    The SimpleType enumeration provides functionality useful when working wit Java's primitive types, their wrapper counterparts as well as with some other crucial types such as String, Date, Enum, Class or Locale types. This enumeration is the single point for "simple type" conversion for many other functionality so code is not scattered around the various libraries disjunct from each other.

    • Enum Constant Detail

      • DEFAULT

        public static final SimpleType DEFAULT
        Convert primitive types (e.g. Byte.TYPE) to their wrapper types (e.g. Byte). Array types are converted to non array types with the according array notation (as of WRAPPER_TYPES).

      • KEEP_TYPES

        public static final SimpleType KEEP_TYPES
        Keep primitive types (e.g. Byte.TYPE) as well as their wrapper types (e.g. Byte). Array types are converted to non array types with the according array notation.

      • WRAPPER_TYPES

        public static final SimpleType WRAPPER_TYPES
        Convert primitive types (e.g. Byte.TYPE) to their wrapper types (e.g. Byte). Array types are converted to non array types with the according array notation.

      • PRIMITIVE_TYPES

        public static final SimpleType PRIMITIVE_TYPES
        Convert wrapper types (e.g. Byte) to their primitive types (e.g. Byte.TYPE). Array types are converted to non array types with the according array notation.

      • KEEP_TYPES_WITH_ARRAY_TYPES

        public static final SimpleType KEEP_TYPES_WITH_ARRAY_TYPES
        Keep primitive types (e.g. Byte.TYPE) as well as their wrapper types (e.g. Byte). According array types are preserved!

      • WRAPPER_TYPES_WITH_ARRAY_TYPES

        public static final SimpleType WRAPPER_TYPES_WITH_ARRAY_TYPES
        Convert primitive types (e.g. Byte.TYPE) to their wrapper types (e.g. Byte). According array types are preserved!

      • PRIMITIVE_TYPES_WITH_ARRAY_TYPES

        public static final SimpleType PRIMITIVE_TYPES_WITH_ARRAY_TYPES
        Convert wrapper types (e.g. Byte) to their primitive types (e.g. Byte.TYPE). According array types are preserved!

    • Method Detail

      • values

        public static SimpleType[] values()
        Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows: 
        for (SimpleType c : SimpleType.values())
    System.out.println(c);
        Returns:
        an array containing the constants of this enum type, in the order they are declared

      • valueOf

        public static SimpleType valueOf​(String name)
        Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
        Parameters:
        name - the name of the enum constant to be returned.
        Returns:
        the enum constant with the specified name
        Throws:
        IllegalArgumentException - if this enum type has no constant with the specified name
        NullPointerException - if the argument is null

      • hasPrimitiveTypeSupport

        public boolean hasPrimitiveTypeSupport()
        Returns true in case primitive (array) types are supported types.
        Returns:
        True in case primitive (array) types are supported types.

      • hasWrapperTypeSupport

        public boolean hasWrapperTypeSupport()
        Returns true in case wrapper (array) types are supported types.
        Returns:
        True in case wrapper (array) types are supported types.

      • hasArrayTypeSupport

        public boolean hasArrayTypeSupport()
        Returns true in case primitive type arrays or arrays of their wrappers are supported types.
        Returns:
        True in case primitive type arrays or arrays of their wrappers are supported types.

      • toType

        public Class<?> toType​(Class<?> aClass)
        Converts the passed type as of the SimpleType.
        Parameters:
        aClass - The type to be converted.
        Returns:
        The converted type.

      • toPrimitiveType

        public static Class<?> toPrimitiveType​(Class<?> aClass)
        Converts the given type to a primitive type if possible and returns the result or null if the given type is not a wrapper type. Convenience method for toPrimitiveType(Class, boolean) without array support.
        Parameters:
        aClass - The type to be converted.
        Returns:
        The converted type.

      • toPrimitiveType

        public static Class<?> toPrimitiveType​(Class<?> aClass,
                                       boolean hasArraySupport)
        Converts the given type to a primitive type if possible and returns the result or null if the given type is not a wrapper type.
        Parameters:
        aClass - The type to be converted.
        hasArraySupport - True in case primitive type arrays or arrays of their wrappers are supported types.
        Returns:
        The converted type.

      • toWrapperType

        public static Class<?> toWrapperType​(Class<?> aClass)
        Converts the given type to a wrapper type if possible and returns the result or null if the given type is not a primitive type. Convenience method for toWrapperType(Class, boolean) without array support.
        Parameters:
        aClass - The type to be converted.
        Returns:
        The converted type.

      • toWrapperType

        public static Class<?> toWrapperType​(Class<?> aClass,
                                     boolean hasArraySupport)
        Converts the given type to a wrapper type if possible and returns the result or null if the given type is not a primitive type.
        Parameters:
        aClass - The type to be converted.
        hasArraySupport - True in case primitive type arrays or arrays of their wrappers are supported types.
        Returns:
        The converted type.

      • isPrimitiveType

        public static boolean isPrimitiveType​(Class<?> aClass,
                                      boolean hasArraySupport)
        Tests whether the given class represents a primitive (array) type.
        Parameters:
        aClass - The type to be tested.
        hasArraySupport - True in case primitive type arrays or arrays of their wrappers are supported types.
        Returns:
        True in case of being a primitive type, else false. A return value of false does not mean that we have a wrapper type (use isWrapperType(Class)).

      • isPrimitiveType

        public static boolean isPrimitiveType​(Class<?> aClass)
        Tests whether the given class represents a primitive type.
        Parameters:
        aClass - The type to be tested.
        Returns:
        True in case of being a primitive type, else false. A return value of false does not mean that we have a wrapper type (use isWrapperType(Class)).

      • isPrimitiveArrayType

        public static boolean isPrimitiveArrayType​(Class<?> aClass)
        Tests whether the given class represents a primitive array type.
        Parameters:
        aClass - The type to be tested.
        Returns:
        True in case of being a primitive array type, else false. A return value of false does not mean that we have a wrapper array type (use isWrapperArrayType(Class)).

      • isWrapperType

        public static boolean isWrapperType​(Class<?> aClass,
                                    boolean hasArraySupport)
        Tests whether the given class represents a wrapper (array) type.
        Parameters:
        aClass - The type to be tested.
        hasArraySupport - True in case wrapper type arrays or arrays of their wrappers are supported types.
        Returns:
        True in case of being a wrapper type, else false. A return value of false does not mean that we have a wrapper type (use isWrapperType(Class)).

      • isWrapperType

        public static boolean isWrapperType​(Class<?> aClass)
        Tests whether the given class represents a wrapper type of a primitive type.
        Parameters:
        aClass - The type to be tested.
        Returns:
        True in case of being a wrapper type of a primitive type, else false. A return value of false does not mean that we have a primitive type (use isPrimitiveType(Class)).

      • isWrapperArrayType

        public static boolean isWrapperArrayType​(Class<?> aClass)
        Tests whether the given class represents a wrapper array type of a primitive array type.
        Parameters:
        aClass - The type to be tested.
        Returns:
        True in case of being a wrapper array type of a primitive array type, else false. A return value of false does not mean that we have a primitive array type (use isPrimitiveArrayType(Class)).

      • isSimpleType

        public static boolean isSimpleType​(Class<?> aClass,
                                   boolean hasArraySupport)
        Tests whether the given class represents a simple type. A simple type is reckoned to be one of the wrapper types Boolean, Byte, Short, Character, Integer, Long, Float or Double as well as their wrapper types as well as the (not that primitive) types String, Enum and Class
        Parameters:
        aClass - The type to be tested.
        hasArraySupport - True in case simple type arrays are supported types.
        Returns:
        True in case of being a simple type.

      • isSimpleType

        public static boolean isSimpleType​(Class<?> aClass)
        Tests whether the given class represents a simple type. A simple type is reckoned to be one of the wrapper types Boolean, Byte, Short, Character, Integer, Long, Float or Double as well as their wrapper types as well as the (not that primitive) types String, Enum and Class
        Parameters:
        aClass - The type to be tested.
        Returns:
        True in case of being a simple type.

      • isSimpleArrayType

        public static boolean isSimpleArrayType​(Class<?> aClass)
        Tests whether the given class represents a simple type array. A simple type is reckoned to be one of the wrapper types Boolean, Byte, Short, Character, Integer, Long, Float or Double as well as their wrapper types as well as the (not that primitive) types String, Enum and Class
        Parameters:
        aClass - The type to be tested.
        Returns:
        True in case of being a simple type array.

      • isCompositeType

        public static boolean isCompositeType​(Class<?> aClass,
                                      boolean hasArraySupport)
        Tests whether the given class represents a composite type. A composite type is not a simple type (nor a primitive type and neither a wrapper type).
        Parameters:
        aClass - The type to be tested.
        hasArraySupport - True in case composite type arrays are supported types.
        Returns:
        True in case of being a composite type.

      • isCompositeType

        public static boolean isCompositeType​(Class<?> aClass)
        Tests whether the given class represents a composite type. A composite type is not a simple type (nor a primitive type and neither a wrapper type).
        Parameters:
        aClass - The type to be tested.
        Returns:
        True in case of being a composite type.

      • isCompositeArrayType

        public static boolean isCompositeArrayType​(Class<?> aClass)
        Tests whether the given class represents a composite type array. A simple type is reckoned to be one of the wrapper types Boolean, Byte, Short, Character, Integer, Long, Float or Double as well as their wrapper types as well as the (not that primitive) types String, Enum and Class
        Parameters:
        aClass - The type to be tested.
        Returns:
        True in case of being a composite type array.

      • fromSimpleType

        public static <T> String fromSimpleType​(T aValue)
        Converts a simple type to a String which can be converted back with the companion method toSimpleType(String, Class).
        Type Parameters:
        T - The simple type's type.
        Parameters:
        aValue - The value of the simple type to be converted.
        Returns:
        The according String or if the value was not a simple type.

      • toSimpleType

        public static <TYPE> TYPE toSimpleType​(String aValue,
                                       Class<TYPE> aType)
        Converts a String to a simple type which can be converted back with the companion method fromSimpleType(Object).
        Type Parameters:
        TYPE - the generic type
        Parameters:
        aValue - The value to be converted to the simple type.
        aType - the a type
        Returns:
        The according simple type or null if the type was not a simple type.

      • invokeSimpleType

        public static <T> boolean invokeSimpleType​(T aToArray,
                                           int aToIndex,
                                           String aToValue,
                                           Class<?> aToType)
                                    throws NoSuchMethodException,
                                           InstantiationException,
                                           IllegalAccessException,
                                           InvocationTargetException,
                                           ClassNotFoundException
        Invokes a array at the given index with a simple type value's String representation, converting the String instance into the according simple type.
        Type Parameters:
        T - The type of the instance on which to do the array invocation.
        Parameters:
        aToArray - the array where to invoke the simple type's value.
        aToIndex - the index into the array where to invoke the value to.
        aToValue - The String representation of the value to be passed to the array.
        aToType - The (simple type) to which the value is to be converted.
        Returns:
        True in case a simple type was detected and invocation was done. False in case the type of the value to be invoked was not a simple type. See also isSimpleType(Class).
        Throws:
        NoSuchMethodException - in case there is none such method for the given instance.
        InstantiationException - thrown in case instantiation of required types failed.
        IllegalAccessException - in case method invocation has access restrictions.
        InvocationTargetException - in case upon invocation an exceptional situation occurred.
        ClassNotFoundException - thrown in case a required type's class was not found on the class path.