Package org.picocontainer.injectors

# Class IterativeInjector<T>

java.lang.Object
org.picocontainer.adapters.AbstractAdapter<T>
org.picocontainer.injectors.AbstractInjector<T>
org.picocontainer.injectors.IterativeInjector<T>

All Implemented Interfaces:
  `Serializable`, `ComponentAdapter<T>`, `ComponentMonitorStrategy`, `Injector<T>`

Direct Known Subclasses:
  `AbstractFieldInjector`, `SetterInjector`

public abstract class IterativeInjector<T> extends AbstractInjector<T>
Injection will happen iteratively after component instantiation

See Also:
  - Serialized Form

## Nested Class Summary

## Nested classes/interfaces inherited from class org.picocontainer.injectors.AbstractInjector

`AbstractInjector.AmbiguousComponentResolutionException, AbstractInjector.CyclicDependencyException, AbstractInjector.NotConcreteRegistrationException, AbstractInjector.UnsatisfiableDependenciesException`

## Nested classes/interfaces inherited from interface org.picocontainer.ComponentAdapter

`ComponentAdapter.NOTHING`

## Field Summary

Fields
Modifier and Type
Field
Description
`protected Annotation[]`
`bindings`
`protected List<AccessibleObject>`
`injectionMembers`
`protected Type[]`
`injectionTypes`

### Fields inherited from class org.picocontainer.injectors.AbstractInjector

`parameters, verifyingGuard`

## Constructor Summary

Constructors
Constructor
Description
`IterativeInjector(Object componentKey, Class componentImplementation, Parameter[] parameters, ComponentMonitor monitor, boolean useNames)`
Constructs a IterativeInjector

## Method Summary

Modifier and Type
Method
Description
`static String`
`crudeMethodSignature(Method method)`
`Object`
`decorateComponentInstance(PicoContainer container, Type into, T instance)`
A preexiting component instance can be injected into after instantiation
`T`
`getComponentInstance(PicoContainer container, Type into)`
Retrieve the component instance.
`protected Constructor`
`getConstructor()`
`protected String`
`getName(Method method)`
`protected void`
`initializeInjectionMembersAndTypeLists()`
`protected abstract Object`
`injectIntoMember(AccessibleObject member, Object componentInstance, Object toInject)`
`protected boolean`
`isInjectorMethod(Method method)`
`protected NameBinding`
`makeParameterNameImpl(AccessibleObject member)`
`protected abstract Object`
`memberInvocationReturn(Object lastReturn, AccessibleObject member, Object instance)`
`protected abstract void`
`unsatisfiedDependencies(PicoContainer container, Set<Type> unsatisfiableDependencyTypes, List<AccessibleObject> unsatisfiableDependencyMembers)`
`void`
`verify(PicoContainer container)`
Verify that all dependencies for this adapter can be satisfied.

### Methods inherited from class org.picocontainer.injectors.AbstractInjector

`accept, box, caughtIllegalAccessException, caughtIllegalAccessException, caughtInstantiationException, caughtInvocationTargetException, createDefaultParameters, getComponentInstance, getDescriptor, newInstance, useNames`

### Methods inherited from class org.picocontainer.adapters.AbstractAdapter

`changeMonitor, checkTypeCompatibility, currentMonitor, findAdapterOfType, getComponentImplementation, getComponentKey, getDelegate, toString`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface org.picocontainer.ComponentAdapter

`findAdapterOfType, getComponentImplementation, getComponentKey, getDelegate`

## Field Details

### injectionMembers

protected transient List<AccessibleObject> injectionMembers

### injectionTypes

protected transient Type[] injectionTypes

### bindings

protected transient Annotation[] bindings

## Constructor Details

### IterativeInjector

public IterativeInjector(Object componentKey, Class componentImplementation, Parameter[] parameters, ComponentMonitor monitor, boolean useNames) throws AbstractInjector.NotConcreteRegistrationException
Constructs a IterativeInjector

Parameters:
  `componentKey` - the search key for this implementation
  `componentImplementation` - the concrete implementation
  `parameters` - the parameters to use for the initialization
  `monitor` - the component monitor used by this addAdapter
  `useNames` - use argument names when looking up dependencies
Throws:
  `AbstractInjector.NotConcreteRegistrationException` - if the implementation is not a concrete class.
  `NullPointerException` - if one of the parameters is `null`

## Method Details

### getConstructor

protected Constructor getConstructor()

### makeParameterNameImpl

protected NameBinding makeParameterNameImpl(AccessibleObject member)

### unsatisfiedDependencies

protected abstract void unsatisfiedDependencies(PicoContainer container, Set<Type> unsatisfiableDependencyTypes, List<AccessibleObject> unsatisfiableDependencyMembers)

### getComponentInstance

public T getComponentInstance(PicoContainer container, Type into) throws PicoCompositionException
Description copied from interface: `ComponentAdapter`
Retrieve the component instance. This method will usually create a new instance each time it is called, but that is not required. For example, `Cached` will always return the same instance.

Specified by:
  `getComponentInstance` in interface `ComponentAdapter<T>`
Specified by:
  `getComponentInstance` in class `AbstractInjector<T>`
Parameters:
  `container` - the `PicoContainer`, that is used to resolve any possible dependencies of the instance.
  `into` - the class that is about to be injected into. Use ComponentAdapter.NOTHING.class if this is not important to you.
Returns:
  the component instance.
Throws:
  `PicoCompositionException` - if the component has dependencies which could not be resolved, or instantiation of the component lead to an ambiguous situation within the container.

### memberInvocationReturn

protected abstract Object memberInvocationReturn(Object lastReturn, AccessibleObject member, Object instance)

### decorateComponentInstance

public Object decorateComponentInstance(PicoContainer container, Type into, T instance)
Description copied from interface: `Injector`
A preexiting component instance can be injected into after instantiation

Specified by:
  `decorateComponentInstance` in interface `Injector<T>`
Overrides:
  `decorateComponentInstance` in class `AbstractInjector<T>`
Parameters:
  `container` - the container that can provide injectable dependencies
  `into` -
  `instance` - the instance to
Returns:

### injectIntoMember

protected abstract Object injectIntoMember(AccessibleObject member, Object componentInstance, Object toInject) throws IllegalAccessException, InvocationTargetException

Throws:
  `IllegalAccessException`
  `InvocationTargetException`

### verify

public void verify(PicoContainer container) throws PicoCompositionException
Description copied from interface: `ComponentAdapter`
Verify that all dependencies for this adapter can be satisfied. Normally, the adapter should verify this by checking that the associated PicoContainer contains all the needed dependencies.

Specified by:
  `verify` in interface `ComponentAdapter<T>`
Overrides:
  `verify` in class `AbstractInjector<T>`
Parameters:
  `container` - the `PicoContainer`, that is used to resolve any possible dependencies of the instance.
Throws:
  `PicoCompositionException` - if one or more dependencies cannot be resolved.

### initializeInjectionMembersAndTypeLists

protected void initializeInjectionMembersAndTypeLists()

### crudeMethodSignature

public static String crudeMethodSignature(Method method)

### getName

protected String getName(Method method)

### isInjectorMethod

protected boolean isInjectorMethod(Method method)