Strategy pattern that allows to change various behaviors of Toothpick. The default configuration is #forProduction(). A custom configuration can be created and used by toothpick, it is even possible to use a composition of the built-in configurations.

Holds the configuration that will be used across the library.

The locator retrieves a Factory for a given class. In case no generated factory for a given class, we throw a NoFactoryFoundException.

Thrown when a binding is illegal.

Default implementation of an injector.

A non thread safe internal provider. It should never be exposed outside of Toothpick.

A non thread safe internal provider. It should never be exposed outside of Toothpick.

Locates the MemberInjector instances. If not MemberInjector is found, we simply return null. This is required to fully support polymorphism when injecting dependencies.

{@inheritDoc}

A note on concurrency :

• all operations related to the scope tree are synchronized on the Toothpick class.
• all operations related to a scope's content (binding & providers) are synchronized on the key (class) of the binding/injection.
• all providers provided by the public API (including Lazy) should return a thread safe provider (done) but internally, we can live with a non synchronized provider.

A scope is one of the most important concept in Toothpick. It is actually important in Dependency Injection at large and Toothpick exposes it to developers.

Conceptually a scope contains toothpick.config.Bindings & scoped instances :

In toothpick, Scopes create a tree (actually a disjoint forest). Each scope can have children scopes. Operations on the scope tree (adding / removing children, etc.) are non thread safe. The implementation of Toothpick provides a Toothpick class that wraps these operations in a thread safe way.

Scopes can be support scope annotations: annotation classes qualified by the annotation. All classes annotated by this annotation will automatically be scoped by Toothpick in the scope that supports them.

Classes that are not annotated with a javax.inject.Scope annotation, also called un-scoped classes, are not associated to a particular scope and can be used in all scopes. Their instances are not recycled, every injection provides a different instance. Scoping a class by annotation is conceptually exactly the same as binding it to itself in a scope.

Scope resolution : when a class is scoped, either by binding it in a module and then installing this module in a scope, or by adding a javax.inject.Scope annotation, it means that all its dependencies must be found in the scope itself or a parent scope. Otherwise, Toothpick will crash at runtime when first instantiating this class. The only other allowed alternative is to have an un-scoped dependency.

A thread safe internal provider. It will be exposed outside of Toothpick.

Main class to access toothpick features. It allows to create / retrieve scopes and perform injections.

The main rule about using TP is : TP will honor all injections in the instances it creates by itself. A soon as you use new Foo, in a provider or a binding for instance, TP is not responsible for injecting Foo; developers have to manually inject the instances they create.