uk.co.strangeskies.reflection

Class AnnotatedTypes

java.lang.Object

uk.co.strangeskies.reflection.AnnotatedTypes

public final class AnnotatedTypes
extends java.lang.Object

A collection of general utility methods relating to annotated types within the Java type system. Utilities related to more specific classes of annotated type may be found in AnnotatedWildcardTypes, AnnotatedParameterizedTypes, and AnnotatedArrayTypes.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	AnnotatedTypes.AnnotatedTypeInternal An internal interface to add some extra functionality onto annotated types.
static class	AnnotatedTypes.AnnotatedTypeParser A parser for AnnotatedTypes, and various related types.

Method Summary

Modifier and Type	Method and Description
static java.util.List<java.lang.reflect.AnnotatedType>	annotated(java.util.Collection<? extends java.lang.reflect.Type> types) Transform a collection of Types into a new list of AnnotatedTypes, according to the behaviour of annotated(Type) applied to element of the collection.
static java.lang.reflect.AnnotatedType[]	annotated(java.lang.reflect.Type... types) Transform an array of Types into a new array of AnnotatedTypes, according to the behaviour of annotated(Type) applied to element of the array.
static java.lang.reflect.AnnotatedType	annotated(java.lang.reflect.Type type) Derive a representation of a given type according the appropriate class of AnnotatedType.
static java.lang.reflect.AnnotatedType	annotated(java.lang.reflect.Type type, java.lang.annotation.Annotation... annotations) Derive a representation of a given type according the appropriate class of AnnotatedType, and with the given annotations.
static java.lang.reflect.AnnotatedType	annotated(java.lang.reflect.Type type, java.util.Collection<java.lang.annotation.Annotation> annotations) Derive a representation of a given type according the appropriate class of AnnotatedType, and with the given annotations.
protected static AnnotatedTypes.AnnotatedTypeInternal[]	annotatedImpl(Isomorphism isomorphism, java.lang.reflect.Type... types)
protected static AnnotatedTypes.AnnotatedTypeInternal	annotatedImpl(Isomorphism isomorphism, java.lang.reflect.Type type)
protected static AnnotatedTypes.AnnotatedTypeInternal	annotatedImpl(Isomorphism isomorphism, java.lang.reflect.Type type, java.util.Collection<java.lang.annotation.Annotation> annotations)
static boolean	equals(java.lang.reflect.AnnotatedType first, java.lang.reflect.AnnotatedType second) A correct equality implementation for annotated types, since the Java specification does not require implementors to provide this.
static java.lang.reflect.AnnotatedType	fromString(java.lang.String typeString) Create an AnnotatedType instance from a parsed String.
static java.lang.reflect.AnnotatedType	fromString(java.lang.String typeString, Imports imports) Create an AnnotatedType instance from a parsed String.
static AnnotatedTypes.AnnotatedTypeParser	getParser() Get the default annotated type parser.
static AnnotatedTypes.AnnotatedTypeParser	getParser(Imports imports) Get an annotated type parser with knowledge of the given imports.
static int	hashCode(java.lang.reflect.AnnotatedType annotatedType) A correct hash code implementation for annotated types, since the Java specification does not require implementors to provide this.
static java.lang.String	toString(java.lang.reflect.AnnotatedType annotatedType) Give a canonical String representation of a given annotated type, which is intended to be more easily human-readable than implementations of Object.toString() for certain implementations of Type.
static java.lang.String	toString(java.lang.reflect.AnnotatedType annotatedType, Imports imports) Give a canonical String representation of a given annotated type, which is intended to be more easily human-readable than implementations of Object.toString() for certain implementations of Type.
static java.lang.reflect.AnnotatedType	wrap(java.lang.reflect.AnnotatedType type) Re-implement the given annotated type with correctly working Object.hashCode() and Object.equals(Object) implementations.
protected static AnnotatedTypes.AnnotatedTypeInternal	wrapImpl(java.lang.reflect.AnnotatedType type)
protected static AnnotatedTypes.AnnotatedTypeInternal[]	wrapImpl(Isomorphism isomorphism, java.lang.reflect.AnnotatedType... type)
protected static AnnotatedTypes.AnnotatedTypeInternal	wrapImpl(Isomorphism isomorphism, java.lang.reflect.AnnotatedType type)

Methods inherited from class java.lang.Object

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

Method Detail

hashCode

public static int hashCode(java.lang.reflect.AnnotatedType annotatedType)

A correct hash code implementation for annotated types, since the Java specification does not require implementors to provide this.

Parameters:

annotatedType - The annotated type whose hash code we wish to determine.

Returns:

A hash code for the given annotated type.

equals

public static boolean equals(java.lang.reflect.AnnotatedType first,
                             java.lang.reflect.AnnotatedType second)

A correct equality implementation for annotated types, since the Java specification does not require implementors to provide this.

Parameters:

first - The first of the two annotated types whose equality we wish to determine.

second - The second of the two annotated types whose equality we wish to determine.

Returns:

True if the two given annotated types are equal, false otherwise.

annotated

public static java.lang.reflect.AnnotatedType[] annotated(java.lang.reflect.Type... types)

Transform an array of Types into a new array of AnnotatedTypes, according to the behaviour of annotated(Type) applied to element of the array.

Parameters:

types - The array of types to transform.

Returns:

A new array of unannotated AnnotatedType instances.

annotated

public static java.util.List<java.lang.reflect.AnnotatedType> annotated(java.util.Collection<? extends java.lang.reflect.Type> types)

Transform a collection of Types into a new list of AnnotatedTypes, according to the behaviour of annotated(Type) applied to element of the collection.

Parameters:

types - The collection of types to transform.

Returns:

A new list of unannotated AnnotatedType instances.

annotated

public static java.lang.reflect.AnnotatedType annotated(java.lang.reflect.Type type)

Derive a representation of a given type according the appropriate class of AnnotatedType.

Parameters:

type - The type for which we wish to derive the annotated form.

Returns:

An AnnotatedType instance of the appropriate class over the given type containing no annotations.

annotated

public static java.lang.reflect.AnnotatedType annotated(java.lang.reflect.Type type,
                                                        java.lang.annotation.Annotation... annotations)

Derive a representation of a given type according the appropriate class of AnnotatedType, and with the given annotations.

Parameters:

type - The type for which we wish to derive the annotated form.

annotations - The annotations we wish for the annotated type to contain.

Returns:

An AnnotatedType instance of the appropriate class over the given type containing the given annotations.

annotated

public static java.lang.reflect.AnnotatedType annotated(java.lang.reflect.Type type,
                                                        java.util.Collection<java.lang.annotation.Annotation> annotations)

Derive a representation of a given type according the appropriate class of AnnotatedType, and with the given annotations.

Parameters:

type - The type for which we wish to derive the annotated form.

annotations - The annotations we wish for the annotated type to contain.

Returns:

An AnnotatedType instance of the appropriate class over the given type containing the given annotations.

annotatedImpl

protected static AnnotatedTypes.AnnotatedTypeInternal[] annotatedImpl(Isomorphism isomorphism,
                                                                      java.lang.reflect.Type... types)

annotatedImpl

protected static AnnotatedTypes.AnnotatedTypeInternal annotatedImpl(Isomorphism isomorphism,
                                                                    java.lang.reflect.Type type)

annotatedImpl

protected static AnnotatedTypes.AnnotatedTypeInternal annotatedImpl(Isomorphism isomorphism,
                                                                    java.lang.reflect.Type type,
                                                                    java.util.Collection<java.lang.annotation.Annotation> annotations)

wrapImpl

protected static AnnotatedTypes.AnnotatedTypeInternal[] wrapImpl(Isomorphism isomorphism,
                                                                 java.lang.reflect.AnnotatedType... type)

wrapImpl

protected static AnnotatedTypes.AnnotatedTypeInternal wrapImpl(java.lang.reflect.AnnotatedType type)

wrapImpl

protected static AnnotatedTypes.AnnotatedTypeInternal wrapImpl(Isomorphism isomorphism,
                                                               java.lang.reflect.AnnotatedType type)

wrap

public static java.lang.reflect.AnnotatedType wrap(java.lang.reflect.AnnotatedType type)

Re-implement the given annotated type with correctly working Object.hashCode() and Object.equals(Object) implementations.

Parameters:

type - The annotated type we wish to re-implement.

Returns:

An AnnotatedType instance equal to the given annotated type.

toString

public static java.lang.String toString(java.lang.reflect.AnnotatedType annotatedType,
                                        Imports imports)

Give a canonical String representation of a given annotated type, which is intended to be more easily human-readable than implementations of Object.toString() for certain implementations of Type. Provided class and package imports allow the names of some classes to be output without full package qualification.

Parameters:

annotatedType - The type of which we wish to determine a string representation.

imports - Classes and packages for which full package qualification may be omitted from output.

Returns:

A canonical string representation of the given type.

toString

public static java.lang.String toString(java.lang.reflect.AnnotatedType annotatedType)

Give a canonical String representation of a given annotated type, which is intended to be more easily human-readable than implementations of Object.toString() for certain implementations of Type.

Parameters:

annotatedType - The type of which we wish to determine a string representation.

Returns:

A canonical string representation of the given type.

fromString

public static java.lang.reflect.AnnotatedType fromString(java.lang.String typeString)

Create an AnnotatedType instance from a parsed String.

Parameters:

typeString - The String to parse.

Returns:

The type described by the String.

fromString

public static java.lang.reflect.AnnotatedType fromString(java.lang.String typeString,
                                                         Imports imports)

Create an AnnotatedType instance from a parsed String. Provided class and package imports allow the names of some classes to be given without full package qualification.

Parameters:

typeString - The String to parse.

imports - Classes and packages for which full package qualification may be omitted from input.

Returns:

The type described by the String.

getParser

public static AnnotatedTypes.AnnotatedTypeParser getParser()

Get the default annotated type parser. All type names will need to be fully qualified to correctly parse.

Returns:

The default annotated type parser

getParser

public static AnnotatedTypes.AnnotatedTypeParser getParser(Imports imports)

Get an annotated type parser with knowledge of the given imports. Type names may omit full qualification if those types are imported according to the given imports.

Parameters:

imports - A list of imports the annotated type parser should be aware of

Returns:

An annotated type parser with knowledge of the given imports