All Classes

Class	Description
AbstractBindingBuilder<T>	Bind a value or constant.
AbstractBindingProcessor	Guarantees that processing of Binding elements happens in a sane way.
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	A support class for Modules which reduces repetition and results in a more readable configuration.
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.TestAnnotation
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 (type and optional annotation) to the strategy for getting instances of the type.
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.
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 runtime code generation and class loading.
BytecodeGen.BridgeClassLoader	Loader for Guice-generated classes.
BytecodeGen.SystemBridgeHolder
BytecodeGen.Visibility	The required visibility of a user's class from a Guice-generated class.
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.
CircularDependencyProxy
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
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.
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 FastClass 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.
DependencyAndSource	Deprecated. The only use of this object is for ProvisionListener.ProvisionInvocation.getDependencyChain() which is also deprecated.
DependencyEdge	Edge from a class or InjectionPoint to the interface node that will satisfy the dependency.
DisableCircularProxiesOption	A request to disable circular proxies.
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>
ErrorHandler	Handles errors in the Injector.
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.MethodHandleWrapper	Wrapper around MethodHandles/MethodHandle, so we can compile+run on java6.
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.
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.
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
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.
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
InheritingState
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.
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.ProviderBindingImpl<T>
InjectorOptionsProcessor	A processor to gather injector options.
InjectorShell	A partially-initialized injector.
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.
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.CustomClassLoadingOption	The options for Guice custom class loading.
InternalFlags.IncludeStackTraceOption	The options for Guice stack trace collection.
InternalFlags.NullableProvidesOption
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>	Binding key consisting of an injection type and an optional annotation.
Key.AnnotationInstanceStrategy
Key.AnnotationStrategy
Key.AnnotationTypeStrategy
Key.NullAnnotationStrategy
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.
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.ThrowableEquivalence
MethodAspect	Ties a matcher to a method interceptor.
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.EmptyModule
Modules.ModuleWriter
Modules.OverriddenModuleBuilder	See the EDSL example at override().
Modules.OverrideModule
Modules.RealOverriddenModuleBuilder
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.
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 FastClass.invoke(java.lang.String, java.lang.Class[], java.lang.Object, java.lang.Object[]) 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.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.IndicesCallbackFilter	A callback filter that maps methods to unique IDs.
ProxyFactory.MethodInterceptorsPair
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.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.BindingSelection<T>
RealMultibinder.PermitDuplicatesModule	We install the permit duplicates configuration as its own binding, all by itself.
RealMultibinder.RealMultibinderCollectionOfProvidersProvider<T>
RealMultibinder.RealMultibinderProvider<T>
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	Provides the binding for java.util.Optional.
RealOptionalBinder.JavaOptionalProviderProvider	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.
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.
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.
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.
State	The inheritable data within an injector.
StaticInjectionRequest	A request to inject the static fields and methods of a type.
Stopwatch	Enables simple performance monitoring.
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
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