All Classes

Class	Description
Assisted	Annotates a parameter within an AssistedInject-annotated constructor.
AssistedFactory	Annotates an abstract class or interface used to create an instance of a type via an AssistedInject constructor.
AssistedInject	Annotates the constuctor of a type that will be created via assisted injection.
Beta	Signifies that a public API (public class, method or field) is subject to incompatible changes, or even removal, in a future release.
Binds	Annotates abstract methods of a Module that delegate bindings.
BindsInstance	Marks a method on a component builder or a parameter on a component factory as binding an instance to some key within the component.
BindsOptionalOf	Annotates methods that declare bindings for Optional containers of values from bindings that may or may not be present in the component.
ClassKey	A MapKey annotation for maps with Class<?> keys.
Component	Annotates an interface or abstract class for which a fully-formed, dependency-injected implementation is to be generated from a set of Component.modules().
Component.Builder	A builder for a component.
Component.Factory	A factory for a component.
ComponentDefinitionType	Specifies the user-defined component that is being implemented by the annotated class.
DaggerCollections	Collection utility methods in service of Dagger internal classes.
DaggerGenerated	Annotates the top-level class of each Dagger generated source file.
DelegateFactory<T>	A DelegateFactory that is used to stitch Provider/Lazy indirection based dependency cycles.
DoubleCheck<T>	A Lazy and Provider implementation that memoizes the value returned from a delegate using the double-check idiom described in Item 71 of Effective Java 2.
ElementsIntoSet	The method's return type is Set<T> and all values are contributed to the set.
Factory<T>	An unscoped Provider.
InjectedFieldSignature	Marks a MembersInjector method for injecting a field with the signature of the field intended to inject.
InstanceFactory<T>	A Factory implementation that returns a single instance for all invocations of InstanceFactory.get().
IntKey	A MapKey annotation for maps with int keys.
IntoMap	The method's return type forms the type argument for the value of a Map<K, Provider<V>>, and the combination of the annotated key and the returned value is contributed to the map as a key/value pair.
IntoSet	The method's return type forms the generic type argument of a Set<T>, and the returned value is contributed to the set.
Lazy<T>	A handle to a lazily-computed value.
LongKey	A MapKey annotation for maps with long keys.
MapBuilder<K,V>	A fluent builder class that returns a Map.
MapFactory<K,V>	A Factory implementation used to implement Map bindings.
MapFactory.Builder<K,V>	A builder for MapFactory.
MapKey	Identifies annotation types that are used to associate keys with values returned by Provides provider methods in order to compose a dagger.multibindings.IntoMap map.
MapProviderFactory<K,V>	A Factory implementation used to implement Map bindings.
MapProviderFactory.Builder<K,V>	A builder for MapProviderFactory.
MembersInjector<T>	Injects dependencies into the fields and methods on instances of type T.
Module	Annotates a class that contributes to the object graph.
Multibinds	Annotates abstract module methods that declare multibindings.
Preconditions	An adaptation of Guava's Preconditions that is specially tailored to support checks applied in Dagger's generated code.
ProviderOfLazy<T>	A Provider of Lazy instances that each delegate to a given Provider.
Provides	Annotates methods of a module to create a provider method binding.
QualifierMetadata	Stores the qualifier information about a type after it's been processed.
Reusable	A scope that indicates that the object returned by a binding may be (but might not be) reused.
ScopeMetadata	Stores the scope information about a type after it's been processed.
SetBuilder<T>	A fluent builder class that returns a Set.
SetFactory<T>	A Factory implementation used to implement Set bindings.
SetFactory.Builder<T>	A builder to accumulate Provider<T> and Provider<Collection<T>> instances.
SingleCheck<T>	A Provider implementation that memoizes the result of another Provider using simple lazy initialization, not the double-checked lock pattern.
StringKey	A MapKey annotation for maps with String keys.
Subcomponent	A subcomponent that inherits the bindings from a parent Component or Subcomponent.
Subcomponent.Builder	A builder for a subcomponent.
Subcomponent.Factory	A factory for a subcomponent.