All Classes and Interfaces
Class
Description
Interface for object that determines handling of annotations in regards
to inheritance, overrides.
Simple implementation that can be configured with default behavior
for unknown annotations, as well as explicit behaviors for
enumerated annotation types.
Enumeration that defines different settings for handling behavior
of individual annotations
Interface for object that can provide mix-ins to override annotations.
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.
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).
Container class used for storing set of annotations resolved for types (classes)
as members (methods, fields, constructors).
Helper class used as key when we need efficient Class-to-value lookups.
Simple helper class used to keep track of 'call stack' for classes being referenced
(as well as unbound variables)
Alternative
ResolvedTypeCache implementation that uses
ConcurrentHashMap for efficient concurrent access and limits maximum
entry count to specified maximum.Interface that defines API for basic filtering objects, used to prune set
of things to include in result sets like flattened member lists.
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).
Container class used to enclose information about a single
ResolvedType
that is part of ResolvedTypeWithMembers.Simple cache used for storing up to specified number of most recently accessed
ResolvedType instances.Simple sub-class to get LRU cache
Builder class used to completely resolve members (fields, methods,
constructors) of
ResolvedTypes (generics-aware classes).Helper class needed when storing methods in maps.
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.
Class that represents a constructor that has fully resolved generic
type information and annotation information.
Fully type-resolved equivalent of
RawMember.Type implementation for classes that do not represent interfaces,
primitive or array types.
Base type for resolved members that take some parameters (e.g.
Type used for Java primitive types (which does not include arrays here).
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.
Simple LRU cache used for storing up to specified number of most recently accessed
ResolvedType instances.Key used for entries cached in a
ResolvedTypeCache.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").
Helper class we use to reduce number of calls to
AnnotationConfiguration;
mostly because determination may be expensive.Helper class used for storing binding of local type variables to
matching resolved types, in context of a single class.
Placeholder used for resolving type assignments to figure out
type parameters for subtypes.
Object that is used for resolving generic type information of a class
so that it is accessible using simple API.