All Classes

Class	Description
AnnotationConfiguration	Interface for object that determines handling of annotations in regards to inheritance, overrides.
AnnotationConfiguration.StdConfiguration	Simple implementation that can be configured with default behavior for unknown annotations, as well as explicit behaviors for enumerated annotation types.
AnnotationInclusion	Enumeration that defines different settings for handling behavior of individual annotations
AnnotationOverrides	Interface for object that can provide mix-ins to override annotations.
AnnotationOverrides.StdBuilder	To make it easy to use simple override implementation (where overrides are direct and explicit), here is a build that allow constructing such override instance.
AnnotationOverrides.StdImpl	Simple implementation configured with explicit associations with target class as key, and overrides as ordered list of classes (with first entry having precedence over later ones).
Annotations	Container class used for storing set of annotations resolved for types (classes) as members (methods, fields, constructors).
ClassKey	Helper class used as key when we need efficient Class-to-value lookups.
ClassStack	Simple helper class used to keep track of 'call stack' for classes being referenced (as well as unbound variables)
ConcurrentTypeCache	Alternative ResolvedTypeCache implementation that uses ConcurrentHashMap for efficient concurrent access and limits maximum entry count to specified maximum.
Filter<T>	Interface that defines API for basic filtering objects, used to prune set of things to include in result sets like flattened member lists.
GenericType<T>	This class is used to pass full generics type information, and avoid problems with type erasure (that basically removes most usable type references from runtime Class objects).
HierarchicType	Container class used to enclose information about a single ResolvedType that is part of ResolvedTypeWithMembers.
LRUTypeCache	Simple cache used for storing up to specified number of most recently accessed ResolvedType instances.
LRUTypeCache.CacheMap	Simple sub-class to get LRU cache
MemberResolver	Builder class used to completely resolve members (fields, methods, constructors) of ResolvedTypes (generics-aware classes).
MethodKey	Helper class needed when storing methods in maps.
RawConstructor
RawField
RawMember	Base class for all "raw" member (field, method, constructor) types; raw means that actual types are not yet resolved, but relationship to declaring type is retained for eventual resolution.
RawMethod
ResolvedArrayType
ResolvedConstructor	Class that represents a constructor that has fully resolved generic type information and annotation information.
ResolvedField
ResolvedInterfaceType
ResolvedMember<T extends java.lang.reflect.Member>	Fully type-resolved equivalent of RawMember.
ResolvedMethod
ResolvedObjectType	Type implementation for classes that do not represent interfaces, primitive or array types.
ResolvedParameterizedMember<T extends java.lang.reflect.Member>	Base type for resolved members that take some parameters (e.g.
ResolvedPrimitiveType	Type used for Java primitive types (which does not include arrays here).
ResolvedRecursiveType	Specialized type placeholder used in cases where type definition is recursive; to avoid infinite loop, reference that would be "back" in hierarchy is represented by an instance of this class.
ResolvedType
ResolvedTypeCache	Simple LRU cache used for storing up to specified number of most recently accessed ResolvedType instances.
ResolvedTypeKey	Key used for entries cached in a ResolvedTypeCache.
ResolvedTypeWithMembers	Class that contains information about fully resolved members of a type; resolution meaning that masking is handled for methods, and all inheritable annotations are flattened using optional overrides as well ("mix-in annotations").
ResolvedTypeWithMembers.AnnotationHandler	Helper class we use to reduce number of calls to AnnotationConfiguration; mostly because determination may be expensive.
TypeBindings	Helper class used for storing binding of local type variables to matching resolved types, in context of a single class.
TypePlaceHolder	Placeholder used for resolving type assignments to figure out type parameters for subtypes.
TypeResolver	Object that is used for resolving generic type information of a class so that it is accessible using simple API.