All Classes

Class	Description
AbstractBindingBuilder<T>	Base class used to create a new binding with the Guice EDSL described in Binder.
AbstractMatcher<T>	Implements and() and or().
AbstractModule	AbstractModule is a helper class used to add bindings to the Guice injector.
AnnotatedBindingBuilder<T>	See the EDSL examples at Binder.
AnnotatedConstantBindingBuilder	See the EDSL examples at Binder.
AnnotatedElementBuilder	See the EDSL examples at Binder.
Annotations	Annotation utilities.
Binder	Collects configuration information (primarily bindings) which will be used to create an Injector.
Binding<T>	A mapping from a Key to the strategy for getting instances of the type.
BindingAnnotation	Annotates annotations which are used for binding.
BindingBuilder<T>	Bind a non-constant key.
BindingImpl<T>
BindingScopingVisitor<V>	Visits each of the strategies used to scope an injection.
BindingSourceRestriction	Contains abstractions for enforcing RestrictedBindingSource.
BindingTargetVisitor<T,V>	Visits each of the strategies used to find an instance to satisfy an injection.
BytecodeGen	Utility methods for circular proxies, faster reflection, and method interception.
BytecodeGen.EnhancerBuilder	Builder of enhanced classes.
ClassBuilding	Entry-point for building enhanced classes and 'fast-class' invocation.
ClassDefining	Entry-point for defining dynamically generated classes.
Classes	Class utilities.
ClassMapKey	Allows @ProvidesIntoMap to specify a class map key.
ConfigurationException	Thrown when a programming error such as a misplaced annotation, illegal binding, or unsupported scope is found.
ConstantBindingBuilder	Binds to a constant value.
ConstantBindingBuilderImpl<T>	Bind a constant.
ConstructorBinding<T>	A binding to the constructor of a concrete clss.
ContinuousStopwatch	A continuously timing stopwatch that is used for simple performance monitoring.
ConvertedConstantBinding<T>	A binding created from converting a bound instance to a new type.
CreationException	Thrown when errors occur while creating a Injector.
DeclaredMembers	Utility class for retrieving declared fields or methods in a particular order, because the JVM doesn't guarantee ordering for listing declared methods.
DefaultBindingScopingVisitor<V>	No-op visitor for subclassing.
DefaultBindingTargetVisitor<T,V>	No-op visitor for subclassing.
DefaultElementVisitor<V>	No-op visitor for subclassing.
Dependency<T>	A variable that can be resolved by an injector.
DisableCircularProxiesOption	A request to disable circular proxies.
Element	A core component of a module or injector.
Elements	Exposes elements of a module so they can be inspected, validated or rewritten.
ElementSource	Contains information about where and how an element was bound.
ElementVisitor<V>	Visit elements.
ErrorDetail<SelfT extends ErrorDetail<SelfT>>	Details about a single Guice error and supports formatting itself in the context of other Guice errors.
ErrorId	Enum used to identify a specific Guice error.
Errors	A collection of error messages.
ErrorsException	Indicates that a result could not be returned while preparing or resolving a binding.
Exposed	Acccompanies a @Provides method annotation in a private module to indicate that the provided binding is exposed.
ExposedBinding<T>	A binding to a key exposed from an enclosed private environment.
ExposureBuilder<T>	For private binder's expose() method.
FailableCache<K,V>	Lazily creates (and caches) values for keys.
GenericErrorDetail	Generic error message representing a Guice internal error.
Guice	The entry point to the Guice framework.
GuiceInternal	Class used for restricting APIs in other packages to only be used by this package.
HasDependencies	Implemented by bindings, providers and instances that expose their dependencies explicitly.
ImplementedBy	A pointer to the default implementation of a type.
Inject	Annotates members of your implementation class (constructors, methods and fields) into which the Injector should inject values.
InjectionListener<I>	Listens for injections into instances of type I.
InjectionPoint	A constructor, field or method that can receive injections.
InjectionRequest<T>	A request to inject the instance fields and methods of an instance.
Injector	Builds the graphs of objects that make up your application.
InstanceBinding<T>	A binding to a single instance.
InterceptorBinding	Registration of interceptors for matching methods of matching classes.
InternalFlags	Contains flags for Guice.
InternalFlags.BytecodeGenOption	Options for controlling whether Guice uses bytecode generation at runtime.
InternalFlags.ColorizeOption	Options for enable or disable using ansi color in error messages.
InternalFlags.CustomClassLoadingOption	The options for Guice custom class loading.
InternalFlags.IncludeStackTraceOption	The options for Guice stack trace collection.
InternalFlags.NullableProvidesOption	Options for handling nullable parameters used in provides methods.
InternalInjectorCreator	Builds a tree of injectors.
InternalProvisionException	A checked exception for provisioning errors.
Key<T>	Guice uses Key objects to identify a dependency that can be resolved by the Guice Injector.
KotlinSupport	Class to conditionally load support for Kotlin features.
KotlinSupportInterface	Interface for accessing information about Kotlin code.
LinkedBindingBuilder<T>	See the EDSL examples at Binder.
LinkedKeyBinding<T>	A binding to a linked key.
MapBinder<K,V>	An API to bind multiple map entries separately, only to later inject them as a complete map.
MapBinderBinding<T>	A binding for a MapBinder.
MapKey	Allows users define customized key type annotations for map bindings by annotating an annotation of a Map's key type.
Matcher<T>	Returns true or false for a given input.
Matchers	Matcher implementations.
MembersInjector<T>	Injects dependencies into the fields and methods on instances of type T.
MembersInjectorLookup<T>	A lookup of the members injector for a type.
Message	An error message and the context in which it occured.
Messages	Utility methods for Message objects
Module	A module contributes configuration information, typically interface bindings, which will be used to create an Injector.
ModuleAnnotatedMethodScanner	Allows extensions to scan modules for annotated methods and bind those methods as providers, similar to @Provides methods.
ModuleAnnotatedMethodScannerBinding	Represents a call to Binder.scanModulesForAnnotatedMethods(com.google.inject.spi.ModuleAnnotatedMethodScanner) in a module.
Modules	Static utility methods for creating and working with instances of Module.
Modules.OverriddenModuleBuilder	See the EDSL example at override().
MoreTypes	Static methods for working with types that we aren't publishing in the public Types API.
MoreTypes.GenericArrayTypeImpl
MoreTypes.ParameterizedTypeImpl
MoreTypes.WildcardTypeImpl	The WildcardType interface supports multiple upper bounds and multiple lower bounds.
Multibinder<T>	An API to bind multiple values separately, only to later inject them as a complete collection.
MultibinderBinding<T>	A binding for a Multibinder.
MultibindingsScanner	Deprecated. This functionality is installed by default.
MultibindingsTargetVisitor<T,V>	A visitor for the multibinder extension.
Named	Annotates named things.
Names	Utility methods for use with @Named.
Nullability	Whether a member supports null values injected.
OptionalBinder<T>	An API to bind optional values, optionally with a default value.
OptionalBinderBinding<T>	A binding for a OptionalBinder.
OutOfScopeException	Thrown from Provider.get() when an attempt is made to access a scoped object while the scope in question is not currently active.
PrivateBinder	Returns a binder whose configuration information is hidden from its environment by default.
PrivateElements	A private collection of elements that are hidden from the enclosing injector or module by default.
PrivateElementsImpl
PrivateModule	A module whose configuration information is hidden from its environment by default.
ProvidedBy	A pointer to the default provider type for a type.
Provider<T>	An object capable of providing instances of type T.
ProviderBinding<T extends Provider<?>>	A binding to a Provider that delegates to the binding for the provided type.
ProviderInstanceBinding<T>	A binding to a provider instance.
ProviderKeyBinding<T>	A binding to a provider key.
ProviderLookup<T>	A lookup of the provider for a type.
ProviderMethod<T>	A provider that invokes a method and returns its result.
ProviderMethodsModule	Creates bindings to methods annotated with @Provides.
Providers	Static utility methods for creating and working with instances of Provider.
ProviderWithDependencies<T>	A provider with dependencies on other injected types.
ProviderWithExtensionVisitor<T>	A Provider that is part of an extension which supports a custom BindingTargetVisitor.
Provides	Annotates methods of a Module to create a provider method binding.
ProvidesIntoMap	Annotates methods of a Module to add items to a MapBinder.
ProvidesIntoOptional	Annotates methods of a Module to add items to a Multibinder.
ProvidesIntoOptional.Type
ProvidesIntoSet	Annotates methods of a Module to add items to a Multibinder.
ProvidesMethodBinding<T>	An @Provides binding or binding produced by a ModuleAnnotatedMethodScanner.
ProvidesMethodTargetVisitor<T,V>	A visitor for the @Provides bindings.
ProvisionException	Indicates that there was a runtime failure while providing an instance.
ProvisionListener	Listens for provisioning of objects.
ProvisionListener.ProvisionInvocation<T>	Encapsulates a single act of provisioning.
ProvisionListenerBinding	Binds keys (picked using a Matcher) to a provision listener.
RealMapBinder<K,V>	The actual mapbinder plays several roles:
RealMultibinder<T>	The actual multibinder plays several roles:
RealOptionalBinder<T>	The actual OptionalBinder plays several roles.
RequireAtInjectOnConstructorsOption	A request to require explicit @Inject annotations on constructors.
RequireExactBindingAnnotationsOption	A request to require exact binding annotations.
RequireExplicitBindingsOption	A request to require explicit bindings.
RestrictedBindingSource	Annotation restricting the binding of the target type to permitted sources.
RestrictedBindingSource.Permit	Meta-annotation indicating that the target annotation is a permit for binding restricted bindings.
RestrictedBindingSource.RestrictionLevel	Level of restriction.
Scope	A scope is a level of visibility that instances provided by Guice may have.
ScopeAnnotation	Annotates annotations which are used for scoping.
ScopeBinding	Registration of a scope annotation with the scope that implements it.
ScopedBindingBuilder	See the EDSL examples at Binder.
Scopes	Built-in scope implementations.
Scoping	References a scope, either directly (as a scope instance), or indirectly (as a scope annotation).
Singleton	Apply this to implementation classes when you want only one instance (per Injector) to be reused for all injections for that binding.
SingletonScope	One instance per Injector.
SourceProvider	Provides access to the calling line of code.
StackTraceElements	Creates stack trace elements for members.
StackTraceElements.InMemoryStackTraceElement	In-Memory version of StackTraceElement that does not store the file name.
Stage	The stage we're running in.
StaticInjectionRequest	A request to inject the static fields and methods of a type.
StringMapKey	Allows @ProvidesIntoMap to specify a string map key.
Toolable	Instructs an Injector running in Stage.TOOL that a method should be injected.
TypeConverter	Converts constant string values to a different type.
TypeConverterBinding	Registration of type converters for matching target types.
TypeEncounter<I>	Context of an injectable type encounter.
TypeListener	Listens for Guice to encounter injectable types.
TypeListenerBinding	Binds types (picked using a Matcher) to an type listener.
TypeLiteral<T>	Represents a generic type T.
Types	Static methods for working with types.
UniqueAnnotations
UntargettedBinding<T>	An untargetted binding.