All Classes and Interfaces

Class	Description
AbstractAttributeFactoryResolver<T,A extends Annotation>
AbstractPluginFactoryResolver<T>
AliasesProvider
AmbiguousInjectConstructorException	Exception thrown when a class has multiple constructors annotated with Inject.
AnnotatedElementAliasesProvider<A extends Annotation>
AnnotatedElementNameProvider<A extends Annotation>	Extracts a specified name for some configurable annotated element.
Assert	Utility class providing common validation logic.
Builder<T>	A type of builder that can be used to configure and create a instances using a Java DSL instead of through a configuration file.
CategoryNameProvider
CircularDependencyException	Exception thrown when a circular dependency is encountered.
Condition	Checks an annotated element to see if it matches some condition.
Conditional	Meta-annotation for conditional annotations to reference the implementing Condition class to handle conditional checks for whether the bindings present in a bundle instance should be registered.
ConditionalOnMissingBinding	Checks if a binding exists for the return type of the annotated Factory method.
ConditionalOnPresentBindings	Only creates a binding if all the requested dependencies exist.
ConditionContext	Provides runtime context to a Condition.
Configurable	Annotates a plugin as being a configurable plugin.
ConfigurableInstanceFactory	Configuration manager for the state of an instance factory.
ConfigurableInstanceFactoryPostProcessor	Provides post-processing capabilities to the initialization of a ConfigurableInstanceFactory.
Constraint	Meta annotation to mark an annotation as a validation constraint.
ConstraintValidationException
ConstraintValidator<A extends Annotation>	Interface that Constraint annotations must implement to perform validation logic.
DefaultInstanceFactory
DependencyChain	Immutable chain of dependency keys assembled while constructing dependency-injected instances.
DI	Factory for instance factories.
DI.FactoryBuilder	Builder DSL for configuring a ConfigurableInstanceFactory using ConfigurableInstanceFactoryPostProcessor instances.
DI.ScopedBindingBuilder<T>	Builder DSL for configuring a scoped binding to be registered with a ConfigurableInstanceFactory.
DI.UnscopedBindingBuilder<T>	Builder DSL for configuring a binding to be registered with a ConfigurableInstanceFactory.
DuplicateBindingException	Thrown when a duplicate binding is attempted to be registered from a bundle in a ConfigurableInstanceFactory.
EnumConverter<E extends Enum<E>>	Converts a String into a Enum.
Factory	Marks a method as a factory for supplying sources of instances of the method's return type.
FactoryResolver<T>	Strategy for resolving factories from existing factories.
FactoryResolversPostProcessor	Base post-processor for registering one or more FactoryResolver instances to a ConfigurableInstanceFactory.
FactoryType	Meta annotation for factories.
GenericFactoryResolversPostProcessor	Post-processor to add factory resolvers for handling Optional and Supplier parameterized types.
Inject	Marks a constructor, field, or method for dependency injection.
InjectException
InjectionPoint<T>
InstanceFactory	Manages dependency injection of a set of bindings between Keys and Suppliers lifecycle-bound to Scopes.
InstancePostProcessor	Provides a lifecycle hook for post-processing instances created by InstanceFactory.
InternalException	Exception thrown when an error occurs while accessing internal resources.
Key<T>	Keys represent a reified type with an optional QualifierType type, name, and namespace.
Key.Builder<T>	Builder class for configuring a new Key instance.
Keys
Named	General naming qualifier for injectable objects.
NamedQualifierNameProvider
NameProvider	Meta annotation for specifying named annotations and how to get a specified name from the named annotation.
Namespace	Annotations to separate NameProvider names into namespaces.
Node	Configurations are represented as a tree of Node instances.
Node.Builder
NoQualifiedBindingException	Exception thrown when a qualified injection point is attempted to be resolved and no binding has been registered previously.
NotInjectableException	Exception thrown when an instance of a type is not injectable.
OnMissingBindingCondition
OnPresentBindingsCondition
OptionalFactoryResolver<T>
Ordered	Specifies the order in which the annotated element should be considered for dependency injection.
OrderedComparator	Comparator for annotated elements using Ordered followed by their name from Keys.getName(java.lang.reflect.Field).
Plugin	Annotation that identifies a Class as a Plugin.
PluginAliases	Identifies a list of aliases for an annotated plugin element.
PluginAliasesProvider
PluginAnnotationFactoryResolversPostProcessor	Post-processor that adds support for various plugin-related annotations.
PluginAttribute	Qualifier for a plugin attribute for configuration options of a plugin.
PluginAttributeFactoryResolver<T>	Factory resolver for PluginAttribute-annotated keys.
PluginAttributeNameProvider
PluginBuilderAttribute	Qualifier for a plugin attribute for configuration options of a plugin.
PluginBuilderAttributeFactoryResolver<T>	Factory resolver for PluginBuilderAttribute-annotated keys.
PluginBuilderAttributeNameProvider
PluginCache
PluginElement	Qualifier for plugin elements which are configurable child plugins.
PluginElementFactoryResolver<T>	Factory resolver for PluginElement-annotated keys.
PluginElementNameProvider
PluginEntry	Descriptor for Plugin metadata.
PluginEntry.Builder
PluginException
PluginFactory	Annotates a static method as a Factory within a Plugin-annotated class.
PluginListFactoryResolver<T>	Factory resolver for List<T> of plugin instances or factories within a namespace.
PluginListSupplierFactoryResolver<T>
PluginMapFactoryResolver<T>	Factory resolver for Map<String, T> of plugin instances or factories keyed by plugin name within a namespace.
PluginMapSupplierFactoryResolver<T>
PluginNameProvider
PluginNamespace	Plugin namespaces are mappings of plugin keys to plugin classes where plugin keys are lower-cased versions of plugin names.
PluginNamespaceFactoryResolver	Factory resolver for PluginNamespace.
PluginNode	Identifies the configuration Node currently being configured.
PluginOptionalFactoryResolver<T>	Factory resolver for Optional<T> plugin instances.
PluginOptionalSupplierFactoryResolver<T>
PluginRegistry	Registry singleton for PluginType maps partitioned by source type and then by category names.
PluginService	Provides plugin metadata for a module.
PluginSetFactoryResolver<T>	Factory resolver for Set<T> of plugin instances or factories within a namespace.
PluginSetSupplierFactoryResolver<T>
PluginStreamFactoryResolver<T>	Factory resolver for Stream<T> of plugin instances or factories within a namespace.
PluginStreamPluginTypeFactoryResolver<T>
PluginStreamSupplierFactoryResolver<T>
PluginType<T>	Plugin Descriptor.
PluginTypeFactoryResolver<T>	Factory resolver for PluginType.
PluginValue	Identifies a Plugin Value and its corresponding attribute alias for configuration formats that don't distinguish between values and attributes.
PluginValueFactoryResolver	Factory resolver for PluginValue-annotated keys.
PluginValueNameProvider
QualifierType	Annotates a qualifier annotation which is used for distinguishing different instances of the same type.
ReflectionAgent	Provides reflection operations using the calling context of another class.
ReflectionException	Exception thrown when there is a problem performing a reflective operation.
ReflectionUtil	Utility class for performing common reflective operations.
Required	Marks a plugin builder field or plugin factory parameter as required.
RequiredClass	Marks a plugin builder field or plugin factory parameter as required.
RequiredClassValidator	Validator that checks for the existence of a class that is required.
RequiredValidator	Validator that checks an object for emptiness.
ResolvableKey<T>
Scope	Scopes control the lifetime of instances with a ScopeType.
ScopeType	Marks an annotation as a scope type.
Singleton	Scope type where provided instances are singletons.
SingletonFactory	Annotation stereotype for Singleton and Factory combined.
SingletonScopePostProcessor	Post-processor that adds support for the Singleton scope.
StringValueResolver	Strategy for replacing strings containing variable placeholders with their resolved values.
SupplierFactoryResolver<T>	Blueprint for supporting generic injection points or keys with a type Supplier<T> for some other type T.
TypeConverter<T>	Interface for doing automatic String conversion to a specific type.
TypeConverterFactory
TypeConverters	Plugin namespace for TypeConverter plugins.
TypeUtil	Utility class for working with Java Types and derivatives.
ValidHost	Indicates that a plugin attribute must be a valid host.
ValidHostValidator	Validator that checks an object to verify it is a valid hostname or IP address.
ValidPort	Indicates that a plugin attribute must be a valid port number.
ValidPortValidator	Validator that checks an object to verify it is a valid port number (an integer between 0 and 65535).