All Classes

Class	Description
AbstractScopeResolver<S>	Abstract base implementation of a ScopeResolver which manages a map of instances per scope.
AmbiguousDependencyException	Thrown when there are multiple candidates for a dependency where only one is expected.
AmbiguousRequiredDependencyException	Thrown when an attempt is made to register a type that would cause a dependency required by another type to become ambiguous.
AmbiguousResolutionException	Thrown when multiple matching instances were available.
AnnotationBasedLifeCycleCallbacksFactory	Implementation of a LifeCycleCallbacksFactory which determines which life cycle methods to call based on configurable annotations.
Annotations	Utilities for working with annotations.
AnnotationStrategy	Strategy for checking and obtaining annotations relevant to dependency injection.
Any	The any qualifier type.
Argument	Indicates a field or method argument is a required argument to be provided at runtime via a factory used for assisted injection.
ArrayUtils	Operations on arrays, primitive arrays (like int[]) and primitive wrapper arrays (like Integer[]).
Assisted	Marks a type with a single abstract method to be automatically created by the assisted type registration extension.
AssistedAnnotationStrategy<P>	Annotation strategy for AssistedTypeRegistrationExtension.
AssistedTypeRegistrationExtension	Extension which provides implementations of abstract classes or interfaces annotated with the configured assist annotation.
AssistedTypeRegistrationExtension.Interceptor<P>	Interceptor for generated subclass of assisted injection factories.
AutoDiscoveryException	Thrown when auto discovery is allowed and the types discovered have definition problems or fail to register as a coherent whole.
BadQualifiedTypeException	Thrown when a QualifiedType is encountered that is unsuitable for injection.
Binding	Bindings represent targets where values can be injected into an instance.
BindingProvider	Provides Bindings for constructors, methods and fields.
BindingProvider.InjectionType
ByteBuddyProxyStrategy	An implementation of ProxyStrategy which uses Byte Buddy to implement the proxy.
ByteBuddyProxyStrategy.Interceptor	Interceptor class to call the underlying delegate object when the proxy is accessed.
CandidateRegistry	Provides methods to manage injection candidates, like registering and removing.
Classes	Support functions for Classes.
ClassInjectableFactory	Factory interface for creating Injectables given a Type.
ClassObjectFactory<T>	Object factory for concrete classes.
ClassUtils	Operates on classes without using reflection.
ComponentScanner	Provides methods to scan packages for injectables.
ComponentScannerFactory	A factory for ComponentScanners which can be configured with relevant annotations to scan for.
ConfigurableAnnotationStrategy	Implementation of AnnotationStrategy which allows configuring one or more annotations used to control injection.
ConfigurableAssistedAnnotationStrategy<A extends java.lang.annotation.Annotation,P>	An implementation of AssistedAnnotationStrategy which can be configured with custom annotations and which extract argument names via the given argument annotation or determines them by parameter, field or method name.
Constructable<T>	Provides an object, potentially constructing it directly or indirectly and any other objects that it depends on.
CreationalContext<T>	Context used to create and destroy instances with injection information.
CreationalContext.Reference<T>	A reference to an instance created by the CreationalContext with which the created instance can be released.
CreationException	Thrown when during (post-)construction of a dependency a problem occurs.
CyclicDependencyException	Thrown when a type or a group of types which are being registered has a dependency which directly or indirectly refers to the type containing the dependency, otherwise known as a cyclical dependency.
Database
Default	The default qualifier type.
DefaultInjectorStrategy	Implementation of InjectorStrategy.
DefinitionException	Thrown during registration of types or instances when the type is incorrectly annotated, cannot be constructed or cannot be injected.
DependencyException	Base exception which signals when an Injector would no longer be able to supply all dependencies for all types it manages if the current action would be executed.
Dependent	Default scope for unscoped objects.
Dependent	Default scope for unscoped objects.
Description	Utility class to describe classes as text.
Discoverer	Potentially discovers additional Injectables.
DiscovererFactory	Gathers fully expanded sets of Injectables based on the given inputs.
DuplicateDependencyException	Thrown when attempting to add a dependency which was already added to the store.
ExtendedScopeResolver	Wrapper for ScopeResolver with additional information useful for the internal workings of the injector framework.
FancyTextProvider
FieldInjectableFactory	Constructs Injectables for Field values of a specific owner Type.
FieldObjectFactory<T>	A Constructable which reads a field to obtain an instance.
Fields	Support functions for Methods.
GenericBindingProvider<B>	Provides bindings for constructors, methods and fields.
GenericBindingProvider.BindingFactory<B>	Factory for creating bindings that have been found.
Injectable<T>	Represents a source for an injectable dependency.
InjectableFactory	Factory for Injectables.
InjectableStore	A store for Injectables which ensures that it at all times contains only injectables that can be fully resolved.
Injection	A target and value to be injected.
InjectionException	Base class for exceptions that can be thrown during injection.
InjectionTargetExtension<T,E>	An interface to allow for custom handling of injection targets of type T.
InjectionTargetExtensionStore	A store for InjectionTargetExtensions.
Injector	An injector is a combination of a CandidateRegistry and an InstanceResolver, providing the functionality of both interfaces in a single type.
Injectors	Factory for CDI style Injectors.
Injectors	Factory for Injectors of various types.
Injectors	Factory for Injectors of various types.
Injectors	Factory for Injectors of various types.
InjectorStrategy	Strategy for controlling the behavior of an injector.
InstanceInjectableFactory	Constructs Injectables for a given object instance.
InstanceInjectionTargetExtension<T>	An InjectionTargetExtension which provides a partial implementation of the Instance provider type.
InstanceResolver	Provides methods to resolve Types to instances.
InstantiationContext<T>	A context which can be used to create instances of type T which match all its criteria.
Key	Represents a Type with a set of qualifier Annotations.
LifeCycleCallbacks	Interface for calling life cycle methods on a given instance.
LifeCycleCallbacksFactory	Factory for LifeCycleCallbacks.
ListInjectionTargetExtension<T>	An InjectionTargetExtension for Lists.
MethodInjectableFactory	Constructs Injectables for Methods part of a specific owner Type.
MethodObjectFactory<T>	A Constructable using a method call to obtain an instance.
Methods	Support functions for Methods.
MissingArgumentException	Thrown by an AssistedAnnotationStrategy when determining an argument name for a method, field or parameter fails.
MissingDependencyException	Thrown when a dependency is not present in the store.
Module	Interface implemented by PluginModule classes which supplies which annotated types are part of a jar is loaded at runtime.
NoProxyStrategy	An implementation of ProxyStrategy that will always throw an exception when attempting to create a proxy, effectively disabling the functionality.
NormalScope	Specifies that an annotation is a normal scope.
Opt	When used in combination with the Inject annotation indicates that the field or method is optional and can be left null if no injection candidate is available.
Plugin	A list of types with a name and ClassLoader together representing a plugin that can be loaded or unloaded as a whole.
PluginManager	Manages Plugins, registering them with a CandidateRegistry when loaded and removing them when unloaded.
PluginModule
Primitives	Utility methods dealing with primitives.
Produces	Indicates a producer method or field.
ProducesTypeRegistrationExtension	Extension which looks for members annotated with a produces annotation, and if found registers these with the injector.
ProviderInjectionTargetExtension<P,E>	Configurable provider InjectionTargetExtension which allows selecting the type of provider it should handle.
ProviderTypeRegistrationExtension	This extension detects if a class implements a method of a provider interface and registers an additional type for the type the provider provides.
ProxyStrategy	A strategy that determines how to create proxies.
ProxyStrategy.InstanceSupplier<T>	Supplies instances that are wrapped by a proxy.
QualifiedType	Represents a fully resolved Type with a set of qualifier Annotations.
QualifiedTypeStore<T>	Store which keeps track of types T for which a Key can be extracted.
ReplaceCamelCaseDisplayNameGenerator	A DisplayNameGenerator which converts camel case test names to normal text.
RequiredDependencyException	Thrown when an attempt is made to register or remove a type that would cause a dependency required by another type to be ambiguous or unresolvable (either by providing a second alternative or by not providing one anymore).
ResolutionException	Base class for exceptions that can be thrown during type safe resolution.
Resolver<T>	Implementers provide a way to look up a type T by Key.
ScopeConflictException	Thrown during registration when a type is determined to dependent on a normal scoped type of a different scope than the type being registered, and the injector is not able or configured to resolve the problem itself (for example, by using a proxy).
ScopeException	Thrown when for scope related problems.
ScopeNotActiveException	Thrown when a scoped instance is required without the appropriate scope being active.
ScopeResolver	Handles resolving of types with a specific scope annotation.
ScopeStrategy	Defines the strategy for scope handling.
SetInjectionTargetExtension<T>	An InjectionTargetExtension for Sets.
SimpleScopeStrategy	An implementation of ScopeStrategy.
SingletonScopeResolver	Scope resolver for singleton scope.
StandardInjector	A standard implementation of Injector provided with the framework.
StyledTextProvider
TextDatabase
TextProvider
TextStyler
TextUppercaser
TypeReference<T>	Helper class that can be subclassed to provide full generic type information.
TypeRegistrationExtension	An extension called during registration of types to derive and register additional types for a given type.
TypeRegistrationExtension.Registry	Allows registration of newly derived types.
Types	Support functions for types, classes and interfaces.
TypeTrait	Traits of an InjectionTargetExtension.
TypeUtils	Utility methods focusing on type inspection, particularly with regard to generics.
TypeUtils.WildcardTypeBuilder	WildcardType builder.
UnknownScopeException	Thrown when an attempt is made to register an injectable which was annotated with a scope for which no corresponding ScopeResolver was provided.
UnsatisfiedDependencyException	Thrown when not all dependencies can be resolved.
UnsatisfiedRequiredDependencyException	Thrown when an attempt is made to remove a type that would cause a dependency required by another type to become unresolvable.
UnsatisfiedResolutionException	Thrown when no matching instance was available or could be created.
UppercaseTextProvider