All Classes

Class	Description
AbstractBindingBuilder<T>	Base class used to create a new binding with the Guice EDSL described in Binder.
AbstractBindingProcessor	Guarantees that processing of Binding elements happens in a sane way.
AbstractGlueGenerator	Support code for generating enhancer/fast-class glue.
AbstractInjectorGrapher	Abstract injector grapher that builds the dependency graph but doesn't render it.
AbstractInjectorGrapher.GrapherParameters	Parameters used to override default settings of the grapher.
AbstractMatcher<T>	Implements and() and or().
AbstractMatcher.AndMatcher<T>
AbstractMatcher.OrMatcher<T>
AbstractModule	AbstractModule is a helper class used to add bindings to the Guice injector.
AbstractProcessor	Abstract base class for creating an injector from module elements.
AbstractServletModuleBinding<T>	Abstract implementation for all servlet module bindings
Alias	Alias between two nodes.
AliasCreator	Creator of node aliases.
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.
Annotations.AnnotationChecker	Checks for the presence of annotations.
Annotations.AnnotationToStringConfig
Annotations.TestAnnotation
AnonymousClassDefiner	ClassDefiner that defines classes using sun.misc.Unsafe#defineAnonymousClass.
ArrowType	Arrow symbols that are available from Graphviz.
Assisted	Annotates an injected parameter or field whose value comes from an argument to a factory method.
AssistedConstructor<T>	Internal respresentation of a constructor annotated with AssistedInject
AssistedInject	When used in tandem with FactoryModuleBuilder, constructors annotated with @AssistedInject indicate that multiple constructors can be injected, each with different parameters.
AssistedInjectBinding<T>	A binding for a factory created by FactoryModuleBuilder.
AssistedInjectTargetVisitor<T,V>	A visitor for the AssistedInject extension.
AssistedMethod	Details about how a method in an assisted inject factory will be assisted.
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.
BindingAlreadySetError	Error reported by Guice when a key is bound at multiple places the injector.
BindingAnnotation	Annotates annotations which are used for binding.
BindingBuilder<T>	Bind a non-constant key.
BindingCollector	Utility class for collecting factory bindings.
BindingEdge	Edge that connects an interface to the type or instance that is bound to implement it.
BindingEdge.Type	Classification for what kind of binding this edge represents.
BindingImpl<T>
BindingProcessor	Handles Binder.bind(com.google.inject.Key<T>) and Binder.bindConstant() elements.
BindingScopingVisitor<V>	Visits each of the strategies used to scope an injection.
BindingSourceRestriction	Contains abstractions for enforcing RestrictedBindingSource.
BindingSourceRestriction.PermitMap	Mapping between an element source and its permit annotations.
BindingSourceRestriction.PermitMapConstruction	Builds the map from each module to all the permit annotations on its module stack.
BindingSourceRestriction.PermitMapConstruction.PermitMapImpl
BindingTargetVisitor<T,V>	Visits each of the strategies used to find an instance to satisfy an injection.
BoundProviderFactory<T>	Delegates to a custom factory which is also bound in the injector.
BytecodeGen	Utility methods for circular proxies, faster reflection, and method interception.
BytecodeGen.EnhancerBuilder	Builder of enhanced classes.
BytecodeTasks	Utility methods to generate common bytecode tasks.
CheckedProvider<T>	Alternative to the Guice Provider that throws a checked Exception.
CheckedProviderMethod<T>	A provider that invokes a method and returns its result.
CheckedProviderMethodsModule	Creates bindings to methods annotated with @CheckedProvides.
CheckedProviderMethodsModule.LogProvider	A provider that returns a logger based on the method name.
CheckedProviders	Static utility methods for creating and working with instances of CheckedProvider.
CheckedProviders.CheckedProviderInvocationHandler<T>
CheckedProviders.ReturningHandler<T>
CheckedProviders.ThrowingHandler
CheckedProviderWithDependencies<T>	A checked provider with dependencies, so HasDependencies can be implemented when using the SecondaryBinder#using methods.
CheckedProvides	Annotates methods of a Module to create a CheckedProvider method binding that can throw exceptions.
CheckedProvideUtils	Utilities for the throwing provider module.
ChildBindingAlreadySetError	Error reported by Guice when a key is already bound in one or more child injectors or private modules.
ChildClassDefiner	ClassDefiner that defines classes using child ClassLoaders.
ChildClassDefiner.ChildLoader	Custom class loader that grants access to defineClass
ChildClassDefiner.ChildLoaderCacheHolder
ChildClassDefiner.SystemChildLoaderHolder
ClassBuilding	Entry-point for building enhanced classes and 'fast-class' invocation.
ClassDefiner	Defines dynamically generated classes.
ClassDefining	Entry-point for defining dynamically generated classes.
ClassDefining.ClassDefinerHolder
Classes	Class utilities.
ClassMapKey	Allows @ProvidesIntoMap to specify a class map key.
CompassPoint	Enum for the "compass point" values used to control where edge end points appear on the graph.
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.
ConstantFactory<T>
ConstructionContext<T>	Context of a dependency construction.
ConstructionProxy<T>	Proxies calls to a Constructor for a class T.
ConstructionProxyFactory<T>	Creates ConstructionProxy instances.
ConstructorBinding<T>	A binding to the constructor of a concrete clss.
ConstructorBindingImpl<T>
ConstructorBindingImpl.Factory<T>
ConstructorInjector<T>	Creates instances using an injectable constructor.
ConstructorInjectorStore	Constructor injectors by type.
ContinuingHttpServletRequest	A wrapper for requests that makes requests immutable, taking a snapshot of the original request.
ContinuingHttpServletRequest.ImmutableCookie
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.
CreationListener	Something that is notified upon creation.
CycleDetectingLock<ID>	Simplified version of Lock that is special due to how it handles deadlocks detection.
CycleDetectingLock.CycleDetectingLockFactory<ID>	Wraps locks so they would never cause a deadlock.
CycleDetectingLock.CycleDetectingLockFactory.ReentrantCycleDetectingLock<ID>	The implementation for CycleDetectingLock.
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.
DefaultConstructionProxyFactory<T>	Produces construction proxies that invoke the class constructor.
DefaultConstructionProxyFactory.FastClassProxy<T>	A ConstructionProxy that uses bytecode generation to invoke the constructor.
DefaultConstructionProxyFactory.ReflectiveProxy<T>
DefaultEdgeCreator	Default edge creator.
DefaultEdgeCreator.EdgeVisitor	BindingTargetVisitor that adds edges to the graph based on the visited Binding.
DefaultElementVisitor<V>	No-op visitor for subclassing.
DefaultFilterPipeline	This default pipeline simply dispatches to web.xml's servlet pipeline.
DefaultNodeCreator	Default node creator.
DefaultNodeCreator.NodeVisitor	BindingTargetVisitor that adds nodes to the graph based on the visited Binding.
DefaultRootKeySetCreator	Root key set creator that starts with all types that are not Guice internal types or the Logger type.
DeferredLookups	Returns providers and members injectors that haven't yet been initialized.
DelayedInitialize	Something that needs some delayed initialization, typically a binding or internal factory that needs to be created & put into the bindings map & then initialized later.
DelegatingInvocationHandler<T>
Dependency<T>	A variable that can be resolved by an injector.
DependencyEdge	Edge from a class or InjectionPoint to the interface node that will satisfy the dependency.
DisableCircularProxiesOption	A request to disable circular proxies.
DuplicateElementError<T>	Error reported by Guice when duplicate elements are found in a Multibinder that does not permit duplicates.
DuplicateElementError.Element<T>
DuplicateMapKeyError<K,V>	Error reported by Guice when a duplicate key is found in a MapBinder that does not permit duplicates.
Edge	Edge in a guice dependency graph.
EdgeCreator	Creator of graph edges to render.
EdgeStyle	Styles for edges.
Element	An internal binding annotation applied to each element in a multibinding.
Element	A core component of a module or injector.
Element.Type
Elements	Exposes elements of a module so they can be inspected, validated or rewritten.
Elements.ElementsAsModule
Elements.ModuleInfo
Elements.RecordingBinder
ElementSource	Contains information about where and how an element was bound.
ElementVisitor<V>	Visit elements.
EncounterImpl<T>
Enhancer	Generates enhanced classes.
EnhancerBuilderImpl	Builder of enhancers that provide method interception via bytecode generation.
ErrorDetail<SelfT extends ErrorDetail<SelfT>>	Details about a single Guice error and supports formatting itself in the context of other Guice errors.
ErrorFormatter	Helper for formatting Guice errors.
ErrorHandler	Handles errors in the Injector.
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.
ExposedBindingImpl<T>
ExposedKeyFactory<T>	This factory exists in a parent injector.
ExposureBuilder<T>	For private binder's expose() method.
FactoryModuleBuilder	Provides a factory that combines the caller's arguments with injector-supplied values to construct objects.
FactoryProvider<F>	Deprecated. use FactoryModuleBuilder instead.
FactoryProvider2<F>	The newer implementation of factory provider.
FactoryProvider2.AssistData	All the data necessary to perform an assisted inject.
FactoryProvider2.PrivateLookup
FactoryProvider2.SuperMethodLookup
FactoryProvider2.SuperMethodSupport	Holder for the appropriate kind of method lookup to use.
FactoryProvider2.ThreadLocalProvider
FactoryProxy<T>	A placeholder which enables us to swap in the real factory once the injector is created.
FailableCache<K,V>	Lazily creates (and caches) values for keys.
FastClass	Generates fast-classes.
FilterChainInvocation	A Filter chain impl which basically passes itself to the "current" filter and iterates the chain on doFilter().
FilterDefinition	An internal representation of a filter definition against a particular URI pattern.
FilterPipeline	An internal dispatcher for guice-servlet registered servlets and filters.
FiltersModuleBuilder	Builds the guice module that binds configured filters, with their wrapper FilterDefinitions.
GeneratedClassDefiner	ClassDefiner that defines classes using a generated access function.
GenericErrorDetail	Generic error message representing a Guice internal error.
GlueException	Thrown when errors occur defining enhancer/fast-class glue.
Graphviz	Annotation for types used by the graphviz grapher.
GraphvizEdge	Data object to encapsulate the attributes of Graphviz edges that we're interested in drawing.
GraphvizGrapher	InjectorGrapher implementation that writes out a Graphviz DOT file of the graph.
GraphvizModule	Module that provides classes needed by GraphvizGrapher.
GraphvizNode	Data object to encapsulate the attributes of Graphviz nodes that we're interested in drawing.
Guice	The entry point to the Guice framework.
GuiceFilter	Apply this filter in web.xml above all other filters (typically), to all requests where you plan to use servlet scopes.
GuiceFilter.Context
GuiceInternal	Class used for restricting APIs in other packages to only be used by this package.
GuiceServletContextListener	As of Guice 2.0 you can still use (your subclasses of) GuiceServletContextListener class as a logical place to create and configure your injector.
HasDependencies	Implemented by bindings, providers and instances that expose their dependencies explicitly.
HiddenClassDefiner	ClassDefiner that defines classes using MethodHandles.Lookup#defineHiddenClass.
ImmutableStringTrie	Immutable space-efficient trie that provides a quick lookup index for a sorted set of non empty strings.
ImmutableStringTrie.Overflow	Immutable trie that delegates searches that lie outside its range to an overflow trie.
ImplementationNode	Node for types that have Dependencys and are bound to InterfaceNodes.
ImplementedBy	A pointer to the default implementation of a type.
Indexer	Visits bindings to return a IndexedBinding that can be used to emulate the binding deduplication that Guice internally performs.
Indexer.BindingType
Indexer.IndexedBinding
Initializable<T>	Holds a reference that requires initialization to be performed before it can be used.
Initializables
Initializer	Manages and injects instances at injector-creation time.
Initializer.InjectableReference<T>
Initializer.InjectableReferenceState
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.
InjectionPoint.InjectableField
InjectionPoint.InjectableMember	Node in the doubly-linked list of injectable members (fields and methods).
InjectionPoint.InjectableMembers	Linked list of injectable members.
InjectionPoint.InjectableMethod
InjectionPoint.OverrideIndex	Keeps track of injectable methods so we can remove methods that get overridden in O(1) time.
InjectionPoint.Position	Position in type hierarchy.
InjectionPoint.Signature	A method signature.
InjectionRequest<T>	A request to inject the instance fields and methods of an instance.
InjectionRequestProcessor	Handles Binder.requestInjection and Binder.requestStaticInjection commands.
Injector	Builds the graphs of objects that make up your application.
InjectorBindingData	A container that stores an injector's binding data.
InjectorGrapher	Guice injector grapher.
InjectorImpl	Default Injector implementation.
InjectorImpl.ConvertedConstantBindingImpl<T>
InjectorImpl.InjectorOptions	Options that control how the injector behaves.
InjectorImpl.JitLimitation	some limitations on what just in time bindings are allowed.
InjectorImpl.MethodInvoker	Invokes a method.
InjectorImpl.SyntheticProviderBindingImpl<T>	A framework-created JIT Provider binding.
InjectorJitBindingData	A container for most just-in-time (JIT) binding data corresponding to an Injector.
InjectorOptionsProcessor	A processor to gather injector options.
InjectorShell	InjectorShell is used by InternalInjectorCreator to recursively create a tree of uninitialized Injectors.
InjectorShell.Builder
InjectorShell.InheritedScannersModule
InjectorShell.InjectorFactory
InjectorShell.LoggerFactory
InjectorShell.RootModule
InstanceBinding<T>	A binding to a single instance.
InstanceBindingImpl<T>
InstanceFilterBinding	A binding to a single instance of a filter.
InstanceFilterBindingImpl	Default implementation of InstanceFilterBinding.
InstanceNode	Node for instances.
InstanceServletBinding	A binding to a single instance of a servlet.
InstanceServletBindingImpl	Default implementation of InstanceServletBinding.
InterceptorBinding	Registration of interceptors for matching methods of matching classes.
InterceptorBindingProcessor	Handles Binder.bindInterceptor commands.
InterceptorStackCallback	Intercepts a method with a stack of interceptors.
InterfaceNode	Node for an interface type that has been bound to an implementation class or instance.
InternalContext	Internal context.
InternalErrorDetail<T extends ErrorDetail<T>>	Represents an error created by Guice as opposed to custom error added to the binder from application code.
InternalFactory<T>	Creates objects which will be injected.
InternalFactoryToInitializableAdapter<T>	Adapts ProviderInstanceBinding providers, ensuring circular proxies fail (or proxy) properly.
InternalFactoryToProviderAdapter<T>
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.
InternalInjectorCreator.ToolStageInjector	Injector exposed to users in Stage.TOOL.
InternalProviderInstanceBindingImpl<T>	A ProviderInstanceBindingImpl for implementing 'native' guice extensions.
InternalProviderInstanceBindingImpl.CyclicFactory<T>	An base factory implementation that can be extended to provide a specialized implementation of a ProviderWithExtensionVisitor and also implements InternalFactory
InternalProviderInstanceBindingImpl.Factory<T>	A base factory implementation.
InternalProviderInstanceBindingImpl.InitializationTiming
InternalProvisionException	A checked exception for provisioning errors.
InternalServletModule	This is a left-factoring of all ServletModules installed in the system.
InternalServletModule.BackwardsCompatibleServletContextProvider	Special Provider that tries to obtain an injected servlet context, specific to the current injector, failing which, it falls back to the static singleton instance that is available in the legacy Guice Servlet.
JndiIntegration	Integrates Guice with JNDI.
JndiIntegration.JndiProvider<T>
Key<T>	Guice uses Key objects to identify a dependency that can be resolved by the Guice Injector.
Key.AnnotationInstanceStrategy
Key.AnnotationStrategy
Key.AnnotationTypeStrategy
Key.NullAnnotationStrategy
KotlinSupport	Class to conditionally load support for Kotlin features.
KotlinSupport.KotlinSupportHolder
KotlinSupport.KotlinUnsupported
KotlinSupportInterface	Interface for accessing information about Kotlin code.
LineNumbers	Looks up line numbers for classes and their members.
LinkedBindingBuilder<T>	See the EDSL examples at Binder.
LinkedBindingImpl<T>
LinkedFilterBinding	A linked binding to a filter.
LinkedFilterBindingImpl	Default implementation of LinkedFilterBinding.
LinkedKeyBinding<T>	A binding to a linked key.
LinkedProviderBindingImpl<T>
LinkedServletBinding	A linked binding to a servlet.
LinkedServletBindingImpl	Default implementation of LinkedServletBinding.
ListenerBindingProcessor	Handles Binder#bindListener commands.
LookupProcessor	Handles Binder.getProvider and Binder.getMembersInjector(TypeLiteral) commands.
Lookups	Accessors for providers and members injectors.
LookupTester	An interface in a different package, so that AssistedInject's main package can't see it.
LookupTester.Hidden
ManagedBinding
ManagedBindingMBean	JMX interface to bindings.
ManagedFilterPipeline	Central routing/dispatch class handles lifecycle of managed filters, and delegates to the servlet pipeline.
ManagedServletPipeline	A wrapping dispatcher for servlets, in much the same way as ManagedFilterPipeline is for filters.
ManagedServletPipeline.RequestDispatcherRequestWrapper
Manager	Provides a JMX interface to Guice.
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.
Matchers.AnnotatedWith
Matchers.AnnotatedWithType
Matchers.Any
Matchers.IdenticalTo
Matchers.InPackage
Matchers.InSubpackage
Matchers.Not<T>
Matchers.Only
Matchers.Returns
Matchers.SubclassesOf
MembersInjector<T>	Injects dependencies into the fields and methods on instances of type T.
MembersInjectorImpl<T>	Injects members of instances of a given type.
MembersInjectorLookup<T>	A lookup of the members injector for a type.
MembersInjectorStore	Members injectors by type.
Message	An error message and the context in which it occured.
MessageProcessor	Handles Binder.addError commands.
Messages	Utility methods for Message objects
Messages.Converter<T>
Messages.FormatOptions
Messages.ThrowableEquivalence
MethodAspect	Ties a matcher to a method interceptor.
MethodPartition	Accumulates methods with the same name and number of parameters.
MissingConstructorError	Error reported when Guice can't find an useable constructor to create objects.
MissingImplementationError<T>	Error reported by Guice when a key is not bound in the injector.
MissingImplementationErrorHints	Helper class to find hints for MissingImplementationError.
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.
ModuleAnnotatedMethodScannerProcessor	Handles Binder.scanModulesForAnnotatedMethods commands.
Modules	Static utility methods for creating and working with instances of Module.
Modules.CombinedModule
Modules.DisableCircularProxiesModule
Modules.EmptyModule
Modules.ModuleWriter
Modules.OverriddenModuleBuilder	See the EDSL example at override().
Modules.OverrideModule
Modules.RealOverriddenModuleBuilder
Modules.RequireAtInjectOnConstructorsModule
Modules.RequireExactBindingAnnotationsModule
Modules.RequireExplicitBindingsModule
ModuleSource	Associated to a module, provides the module class name, the parent module source, and the call stack that ends just before the module configure(Binder) method invocation.
MoreTypes	Static methods for working with types that we aren't publishing in the public Types API.
MoreTypes.CompositeType	A type formed from other types, such as arrays, parameterized types or wildcard types
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.
NamedImpl
NameFactory	Interface for a service that provides nice Strings that we can display in the graph for the types that come up in Bindings.
Names	Utility methods for use with @Named.
Node	Node in a guice dependency graph.
NodeCreator	Creator of graph nodes.
NodeId	ID of a node in the graph.
NodeId.NodeType	Type of node.
NodeShape	Enum for the shapes that are most interesting for Guice graphing.
NodeStyle	Styles for nodes.
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.
PackageNameCompressor	Munges an error message to remove/shorten package names and adds a legend at the end.
Parameter	Models a method or constructor parameter.
ParameterListKey	A list of TypeLiterals to match an injectable Constructor's assited parameter types to the corresponding factory method.
PortIdFactory	Interface for a service that returns Graphviz port IDs, used for naming the rows in ImplementationNode-displaying GraphvizNodes.
PortIdFactoryImpl	Implementation of PortIdFactory.
PrivateBinder	Returns a binder whose configuration information is hidden from its environment by default.
PrivateElementProcessor	Handles Binder.newPrivateBinder() elements.
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.
ProcessedBindingData	Keeps track of creation listeners & uninitialized bindings, so they can be processed after bindings are recorded.
ProvidedBy	A pointer to the default provider type for a type.
ProvidedByInternalFactory<T>	An InternalFactory for @ProvidedBy bindings.
Provider<T>	An object capable of providing instances of type T.
ProviderAliasCreator	Alias creator that creates an alias for each ProviderBinding.
ProviderBinding<T extends Provider<?>>	A binding to a Provider that delegates to the binding for the provided type.
ProviderChecker	Helper methods to verify the correctness of CheckedProvider interfaces.
ProviderChecker.NotSyntheticOrBridgePredicate
ProviderInstanceBinding<T>	A binding to a provider instance.
ProviderInstanceBindingImpl<T>
ProviderInternalFactory<T>	Base class for InternalFactories that are used by Providers, to handle circular dependencies.
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.
ProviderMethod.FastClassProviderMethod<T>	A ProviderMethod implementation that uses bytecode generation to invoke the provider method.
ProviderMethod.ReflectionProviderMethod<T>	A ProviderMethod implementation that invokes the method using normal java reflection.
ProviderMethodsModule	Creates bindings to methods annotated with @Provides.
ProviderMethodsModule.MethodAndAnnotation
ProviderMethodsModule.Signature
Providers	Static utility methods for creating and working with instances of Provider.
Providers.ConstantProvider<T>
Providers.GuicifiedProvider<T>
Providers.GuicifiedProviderWithDependencies<T>
ProviderToInternalFactoryAdapter<T>
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.
ProvidesMethodScanner	A ModuleAnnotatedMethodScanner that handles the , ProvidesIntoSet, ProvidesIntoMap and ProvidesIntoOptional annotations.
ProvidesMethodScanner.AnnotationOrError
ProvidesMethodScanner.TypeAndValue<T>
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.
ProvisionListenerCallbackStore	ProvisionListenerStackCallback for each key.
ProvisionListenerCallbackStore.KeyBinding	A struct that holds key & binding but uses just key for equality/hashcode.
ProvisionListenerStackCallback<T>	Intercepts provisions with a stack of listeners.
ProvisionListenerStackCallback.ProvisionCallback<T>
ProxyFactory<T>	Builds a construction proxy that can participate in AOP.
ProxyFactory.ProxyConstructor<T>	Constructs instances that participate in AOP.
RealElement	An implementation of Element.
RealMapBinder<K,V>	The actual mapbinder plays several roles:
RealMapBinder.BindingSelection<K,V>	The BindingSelection contains some of the core state and logic for the MapBinder.
RealMapBinder.BindingSelection.InitializationState
RealMapBinder.ExtensionRealMapProvider<K,V>	Implementation of a provider instance for the map that also exposes details about the MapBinder using the extension SPI, delegating to another provider instance for non-extension (e.g, the actual provider instance info) data.
RealMapBinder.MultimapBinder<K,V>	Binds Map<K, Set<V>> and {Map<K, Set<Provider<V>>>.
RealMapBinder.MultimapBinder.RealMultimapProvider<K,V>
RealMapBinder.MultimapBinder.RealMultimapProvider.PerKeyData<K,V>	A simple class to hold a key and the associated bindings as an array.
RealMapBinder.MultimapBinder.RealProviderMultimapProvider<K,V>
RealMapBinder.ProviderMapEntry<K,V>	A factory for a Map.Entry<K, Provider<V>>.
RealMapBinder.RealMapBinderProviderWithDependencies<K,V,P>	A base class for ProviderWithDependencies that need equality based on a specific object.
RealMapBinder.RealMapProvider<K,V>
RealMapBinder.RealMultimapBinderProviderWithDependencies<K,V,P>	A base class for ProviderWithDependencies that need equality based on a specific object.
RealMapBinder.RealProviderMapProvider<K,V>
RealMultibinder<T>	The actual multibinder plays several roles:
RealMultibinder.BaseFactory<ValueT,ProvidedT>	Base implement of InternalProviderInstanceBindingImpl.Factory that works based on a RealMultibinder.BindingSelection, allowing provider instances for various bindings to be implemented with less duplication.
RealMultibinder.BindingSelection<T>
RealMultibinder.ExtensionRealMultibinderProvider<T>	Implementation of BaseFactory that exposes details about the multibinder through the extension SPI.
RealMultibinder.PermitDuplicatesModule	We install the permit duplicates configuration as its own binding, all by itself.
RealMultibinder.RealMultibinderCollectionOfProvidersProvider<T>	Implementation of BaseFactory that exposes a collection of providers of the values in the set.
RealMultibinder.RealMultibinderProvider<T>	Provider instance implementation that provides the actual set of values.
RealOptionalBinder<T>	The actual OptionalBinder plays several roles.
RealOptionalBinder.Actual
RealOptionalBinder.ActualImpl
RealOptionalBinder.BaseAnnotation
RealOptionalBinder.BindingSelection<T>	A helper object that implements the core logic for deciding what the implementation of the binding will be.
RealOptionalBinder.Default
RealOptionalBinder.DefaultImpl
RealOptionalBinder.JavaOptionalProvider<T>	Provides the binding for java.util.Optional.
RealOptionalBinder.JavaOptionalProviderProvider<T>	Provides the binding for java.util.Optional>.
RealOptionalBinder.RealDirectTypeProvider<T>	Provides the binding for T, conditionally installed by calling setBinding/setDefault.
RealOptionalBinder.RealOptionalBinderProviderWithDependencies<T,P>	A base class for ProviderWithDependencies that need equality based on a specific object.
RealOptionalBinder.RealOptionalKeyProvider<T>	Provides the binding for Optional.
RealOptionalBinder.RealOptionalProviderProvider<T>	Provides the binding for Optional>.
RealOptionalBinder.Source
RequestParameters	Apply this to field or parameters of type Map<String, String[]> when you want the HTTP request parameter map to be injected.
RequestScoped	Apply this to implementation classes when you want one instance per request.
RequestScoper	Object that can be used to apply a request scope to a block of code.
RequestScoper.CloseableScope	Closeable subclass that does not throw any exceptions from close.
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.
RootKeySetCreator	Creator of the default starting set of keys to graph.
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.
ScopeBindingProcessor	Handles Binder.bindScope commands.
ScopedBindingBuilder	See the EDSL examples at Binder.
ScopeNotFoundError	Error reported by Guice when a scope annotation is not bound to any scope implementation.
Scopes	Built-in scope implementations.
Scoping	References a scope, either directly (as a scope instance), or indirectly (as a scope annotation).
ScopingException	Exception thrown when there was a failure entering request scope.
ScopingOnly	Annotates a GuiceFilter that provides scope functionality, but doesn't dispatch to ServletModule bound servlets or filters.
ServletDefinition	An internal representation of a servlet definition mapped to a particular URI pattern.
ServletModule	Configures the servlet scopes and creates bindings for the servlet API objects so you can inject the request, response, session, etc.
ServletModule.FilterKeyBindingBuilder	See the EDSL examples at ServletModule.configureServlets()
ServletModule.ServletKeyBindingBuilder	See the EDSL examples at ServletModule.configureServlets()
ServletModuleBinding	A binding created by ServletModule.
ServletModuleTargetVisitor<T,V>	A visitor for the servlet extension.
ServletScopes	Servlet scopes.
ServletScopes.Context
ServletScopes.NullObject	A sentinel attribute value representing null.
ServletScopes.RequestScope
ServletScopes.SessionScope
ServletsModuleBuilder	Builds the guice module that binds configured servlets, with their wrapper ServletDefinitions.
ServletUtils	Some servlet utility methods.
ServletUtils.ByteAccumulator	Accumulates byte sequences while decoding strings, and encodes them into a StringBuilder.
SessionScoped	Apply this to implementation classes when you want one instance per session.
ShortNameFactory	Reasonable implementation for NameFactory.
SingleFieldInjector	Sets an injectable field.
SingleMemberInjector	Injects a field or method of a given object.
SingleMethodInjector	Invokes an injectable method.
SingleParameterInjector<T>	Resolves a single parameter, to be used in a constructor or method invocation.
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.
SourceFormatter	Formatting a single source in Guice error message.
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.
ThrowingInject	A version of @Inject designed for ThrowingProviders.
ThrowingProvider<T,E extends java.lang.Exception>	Deprecated. use CheckedProvider instead.
ThrowingProviderBinder	Builds a binding for a CheckedProvider.
ThrowingProviderBinder.Result	Represents the returned value from a call to CheckedProvider.get().
ThrowingProviderBinder.ResultException	RuntimeException class to wrap exceptions from the checked provider.
Toolable	Instructs an Injector running in Stage.TOOL that a method should be injected.
TransitiveDependencyVisitor	BindingTargetVisitor that returns a Collection of the Keys of each Binding's dependencies.
TypeConverter	Converts constant string values to a different type.
TypeConverterBinding	Registration of type converters for matching target types.
TypeConverterBindingProcessor	Handles Binder.convertToTypes commands.
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
UniqueAnnotations.Internal
UnsafeClassDefiner	ClassDefiner that defines classes using sun.misc.Unsafe.
UnsafeClassDefiner.ClassLoaderDefineClassHolder
UnsafeClassDefiner.DefineClassCacheHolder
UntargettedBinding<T>	An untargetted binding.
UntargettedBindingImpl<T>
UntargettedBindingProcessor	Processes just UntargettedBindings.
UriPatternMatcher	A general interface for matching a URI against a URI pattern.
UriPatternType	An enumeration of the available URI-pattern matching styles
UriPatternType.RegexUriPatternMatcher	Matches URIs using a regular expression.
UriPatternType.ServletStyleUriPatternMatcher	Matches URIs using the pattern grammar of the Servlet API and web.xml.
UriPatternType.ServletStyleUriPatternMatcher.Kind
WeakKeySet	Minimal set that doesn't hold strong references to the contained keys.
WeakKeySet.KeyAndSource