ProductionComponent

```
@Documented
 @Target(value=TYPE)
 @Beta
public @interface ProductionComponent
```
Annotates an interface or abstract class for which a fully-formed, dependency-injected implementation is to be generated from a set of modules. The generated class will have the name of the type annotated with @ProductionComponent prepended with Dagger. For example, @ProductionComponent interface MyComponent {...} will produce an implementation named DaggerMyComponent.
Each Produces method that contributes to the component will be called at most once per component instance, no matter how many times that binding is used as a dependency. TODO(beder): Decide on how scope works for producers.
Component methods

Every type annotated with @ProductionComponent must contain at least one abstract component method. Component methods must represent production. Production methods have no arguments and return either a ListenableFuture or Producer of a type that is injected, provided, or produced. Each may have a Qualifier annotation as well. The following are all valid production method declarations:
```
    ListenableFuture<SomeType> getSomeType();
    Producer<Set<SomeType>> getSomeTypes();
    @Response ListenableFuture<Html> getResponse();
 
```
Exceptions

When a producer throws an exception, the exception will be propagated to its downstream producers in the following way: if the downstream producer injects a type T, then that downstream producer will be skipped, and the exception propagated to its downstream producers; and if the downstream producer injects a Produced<T>, then the downstream producer will be run with the exception stored in the Produced<T>.
If a non-execution exception is thrown (e.g., an InterruptedException or CancellationException), then exception is handled as in Futures.transform(com.google.common.util.concurrent.ListenableFuture<I>, com.google.common.base.Function<? super I, ? extends O>).
Executor

The component must include a binding for @Production Executor; this binding will be called exactly once, and the provided executor will be used by the framework to schedule all producer methods (for this component, and any ProductionSubcomponent it may have.

Optional Element Summary

Optional Elements
Modifier and Type	Optional Element and Description
`Class<?>[]`	`dependencies` A list of types that are to be used as component dependencies.
`Class<?>[]`	`modules` A list of classes annotated with `Module` or `ProducerModule` whose bindings are used to generate the component implementation.

- Element Detail
  - modules
```
public abstract Class<?>[] modules
```
    A list of classes annotated with Module or ProducerModule whose bindings are used to generate the component implementation.
    
    Default:
    
    {}
- - dependencies
```
public abstract Class<?>[] dependencies
```
    A list of types that are to be used as component dependencies.
    
    Default:
    
    {}

Annotation Type ProductionComponent

Component methods

Exceptions

Executor

Optional Element Summary

Element Detail

modules

dependencies