Context (Grapht Dependency Injector 0.11.0-BETA2 API)

All Known Implementing Classes:

AbstractContext, InjectorBuilder
```
public interface Context
```
Context is the main entry point for configuring bind rules using the fluent API. The dependency injector uses the contexts to limit the scope of a binding. Every time a dependency is satisfied, that type (and possibly Qualifier) is pushed onto the context stack. Thus, if two different types each require a Foo, there can be two different bindings activated depending on which first type is in the context stack.
The "root" context is an empty stack, and will always be matched. When creating bindings, the context stack can be configured by calling in(Class) or in(Class, Class).

Author:

GroupLens Research

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`Context`	`at(Annotation qualifier, Class<?> type)` Create a new Context that extends the current context stack with the given class, qualified by the specific Annotation instance.
`Context`	`at(Class<?> type)` Create a new Context that extends the current context stack with the given class type as an anchored match.
`Context`	`at(Class<? extends Annotation> qualifier, Class<?> type)` Create a new Context that extends the current context stack with the given class and `Qualifier` annotation as an anchored match.
`<T> Binding<T>`	`bind(Class<? extends Annotation> qual, Class<T> type)` Start a new binding for a qualified type.
`<T> Binding<T>`	`bind(Class<T> type)` Start a new binding for the given type T within the scope of this context.
`<T> Binding<T>`	`bindAny(Class<T> type)` Start a new binding for a type irrespective of qualifier.
`Context`	`in(Annotation qualifier, Class<?> type)` Deprecated. Use `within(Annotation, Class)`.
`Context`	`in(Class<?> type)` Deprecated. Use `within(Class)`.
`Context`	`in(Class<? extends Annotation> qualifier, Class<?> type)` Deprecated. Use `within(Class, Class)`.
`Context`	`matching(ContextPattern pattern)` Restruct context to matching a particular pattern.
`Context`	`within(Annotation qualifier, Class<?> type)` Create a new Context that extends the current context stack with the given class, qualified by the specific Annotation instance.
`Context`	`within(Class<?> type)` Create a new Context that extends the current context stack with the given class type.
`Context`	`within(Class<? extends Annotation> qualifier, Class<?> type)` Create a new Context that extends the current context stack with the given class and `Qualifier` annotation.

- Method Detail
  - bind
```
<T> Binding<T> bind(Class<T> type)
```
    Start a new binding for the given type T within the scope of this context. The returned Binding instance can be configured and completed by invoking one of its various to() methods. Unless further configuration is done, this binding will match unqualified dependencies and dependencies with a qualifier annotated with AllowUnqualifiedMatch.
    
    Type Parameters:
    
    T - The matched source type
    
    Parameters:
    
    type - The raw class that is matched
    
    Returns:
    
    A new binding in this context for type T
  - bind
```
<T> Binding<T> bind(Class<? extends Annotation> qual,
                    Class<T> type)
```
    Start a new binding for a qualified type. A shortcut for bind(type).withQualifier(qual).
    
    Type Parameters:
    
    T - The type to bind.
    
    Parameters:
    
    qual - The type's qualifier.
    
    type - The type to bind.
    
    Returns:
    
    A new binding in this context for T with qualifier qual.
    
    See Also:
    
    Binding.withQualifier(Class)
  - bindAny
```
<T> Binding<T> bindAny(Class<T> type)
```
    Start a new binding for a type irrespective of qualifier. This is a shortcut for bind(type).withAnyQualifier().
    
    Parameters:
    
    type - The type.
    
    Returns:
    
    A new binding in this context for type T with any (or no) qualifier.
  - in
```
@Deprecated
Context in(Class<?> type)
```
    Deprecated. Use within(Class).
  - in
```
@Deprecated
Context in(@Nullable
                        Class<? extends Annotation> qualifier,
                        Class<?> type)
```
    Deprecated. Use within(Class, Class).
  - in
```
@Deprecated
Context in(@Nullable
                        Annotation qualifier,
                        Class<?> type)
```
    Deprecated. Use within(Annotation, Class).
  - within
```
Context within(Class<?> type)
```
    Create a new Context that extends the current context stack with the given class type. This matches with the default Qualifier. This is equivalent to within(null, type);
    
    Parameters:
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
  - within
```
Context within(@Nullable
               Class<? extends Annotation> qualifier,
               Class<?> type)
```
    Create a new Context that extends the current context stack with the given class and Qualifier annotation. If the qualifier is null, the default or null qualifier is used.
    
    Parameters:
    
    qualifier - The qualifier type that must be matched along with the type
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
  - within
```
Context within(@Nullable
               Annotation qualifier,
               Class<?> type)
```
    Create a new Context that extends the current context stack with the given class, qualified by the specific Annotation instance. If the qualifier is null, the default or null qualifier is used.
    The annotation provided must be serializable. Annotations built by AnnotationBuilder (recommended) or retrieved from the Java reflection API are serializable; if you use some other annotation implementation, it must be serializable.
    
    Parameters:
    
    qualifier - The qualifier instance that must be matched along with the type
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
  - matching
```
Context matching(ContextPattern pattern)
```
    Restruct context to matching a particular pattern. The pattern is appended to the pattern generated by the other context-restriction methods. This is a high-powered method that won't be needed in most situations, but allows fine-grained control of context matching.
    
    Parameters:
    
    pattern - The context pattern to match.
    
    Returns:
    
    A context with longer context.
  - at
```
Context at(Class<?> type)
```
    Create a new Context that extends the current context stack with the given class type as an anchored match. This matches with the default Qualifier. This is equivalent to at(null, type);
    
    Parameters:
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
    
    See Also:
    
    at(Class, Class)
  - at
```
Context at(@Nullable
           Class<? extends Annotation> qualifier,
           Class<?> type)
```
    Create a new Context that extends the current context stack with the given class and Qualifier annotation as an anchored match. If the qualifier is null, the default or null qualifier is used.
    Unlike in(Class,Class), this match is anchored — that is, it only matches at the end of a context chain. Context is matched if it ends with this or, if further context is opened inside this context, if the inner context matches immediately.
    
    Parameters:
    
    qualifier - The qualifier type that must be matched along with the type
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack
  - at
```
Context at(@Nullable
           Annotation qualifier,
           Class<?> type)
```
    Create a new Context that extends the current context stack with the given class, qualified by the specific Annotation instance. as an anchored match. If the qualifier is null, the default or null qualifier is used.
    The annotation provided must be serializable. Annotations built by AnnotationBuilder (recommended) or retrieved from the Java reflection API are serializable; if you use some other annotation implementation, it must be serializable.
    
    Parameters:
    
    qualifier - The qualifier instance that must be matched along with the type
    
    type - The type to extend this context by
    
    Returns:
    
    A new Context with a longer context stack

Interface Context

Method Summary

Method Detail

bind

bind

bindAny

in

in

in

within

within

within

matching

at

at

at