Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.picocontainer.injectors
Class FactoryInjector<T>

    java.lang.Object
      org.picocontainer.injectors.FactoryInjector<T>

All Implemented Interfaces:
  ComponentAdapter<T>, Injector<T>

    public abstract class FactoryInjector<T>

extends Object
implements Injector<T>

An Injector which provides an custom instance in a factory style

Author:
  Paul Hammant

Nested Class Summary
`static class` | `FactoryInjector.CantWorkItOut`

Nested classes/interfaces inherited from interface org.picocontainer.ComponentAdapter
`ComponentAdapter.NOTHING`

Constructor Summary
`FactoryInjector()`
`FactoryInjector(Class<T> key)`

Method Summary
`void` | `accept(PicoVisitor visitor)` Accepts a visitor for this ComponentAdapter.
`boolean` | `componentHasLifecycle()`
`Object` | `decorateComponentInstance(PicoContainer container, Type into, T instance)` A preexiting component instance can be injected into after instantiation
`void` | `dispose(PicoContainer container)`
`
`<U extends ComponentAdapter> U`
` | `findAdapterOfType(Class<U> componentAdapterType)` Locates a component adapter of type componentAdapterType in the ComponentAdapter chain.
`static Class<?>` | `getClass(Type type)`
`Class<T>` | `getComponentImplementation()` Retrieve the class of the component.
`T` | `getComponentInstance(PicoContainer container)` Retrieve the component instance.
`abstract T` | `getComponentInstance(PicoContainer container, Type into)` Retrieve the component instance.
`Object` | `getComponentKey()` Retrieve the key associated with the component.
`ComponentAdapter<T>` | `getDelegate()` Component adapters may be nested in a chain, and this method is used to grab the next ComponentAdapter in the chain.
`String` | `getDescriptor()` Get a string key descriptor of the component adapter.
`static
`<T> List<Class<?>>`
` | `getTypeArguments(Class<FactoryInjector> class1, Class<? extends Object> class2)` Get the actual type arguments a child class has used to extend a generic base class.
`void` | `start(PicoContainer container)`
`void` | `stop(PicoContainer container)`
`void` | `verify(PicoContainer container)` Verify that all dependencies for this adapter can be satisfied.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### FactoryInjector

    public FactoryInjector()
                    throws PicoCompositionException

Throws:
  `PicoCompositionException`

### FactoryInjector

    public FactoryInjector(Class<T> key)

Method Detail

### getClass

    public static Class<?> getClass(Type type)

### getTypeArguments

    public static <T> List<Class<?>> getTypeArguments(Class<FactoryInjector> class1,
                                                      Class<? extends Object> class2)

  Get the actual type arguments a child class has used to extend a generic base class.

  Parameters:
    `class1` - the base class
    `class2` - the child class
  Returns:
    a list of the raw classes for the actual type arguments.

### getComponentKey

    public Object getComponentKey()

  Description copied from interface: `ComponentAdapter`
  Retrieve the key associated with the component.

  Specified by:
    `getComponentKey` in interface `ComponentAdapter<T>`
  Returns:
    the component's key. Should either be a class type (normally an interface) or an identifier that is unique (within the scope of the current PicoContainer).

### getComponentImplementation

    public Class<T> getComponentImplementation()

  Description copied from interface: `ComponentAdapter`
  Retrieve the class of the component.

  Specified by:
    `getComponentImplementation` in interface `ComponentAdapter<T>`
  Returns:
    the component's implementation class. Should normally be a concrete class (ie, a class that can be instantiated).

### accept

    public void accept(PicoVisitor visitor)

  Description copied from interface: `ComponentAdapter`
  Accepts a visitor for this ComponentAdapter. The method is normally called by visiting a `PicoContainer`, that cascades the visitor also down to all its ComponentAdapter instances.

  Specified by:
    `accept` in interface `ComponentAdapter<T>`
  Parameters:
    `visitor` - the visitor.

### getDelegate

    public ComponentAdapter<T> getDelegate()

  Description copied from interface: `ComponentAdapter`
  Component adapters may be nested in a chain, and this method is used to grab the next ComponentAdapter in the chain.

  Specified by:
    `getDelegate` in interface `ComponentAdapter<T>`
  Returns:
    the next component adapter in line or null if there is no delegate ComponentAdapter.

### findAdapterOfType

    public <U extends ComponentAdapter> U findAdapterOfType(Class<U> componentAdapterType)

  Description copied from interface: `ComponentAdapter`
  Locates a component adapter of type componentAdapterType in the ComponentAdapter chain. Will return null if there is no adapter of the given type.

  Specified by:
    `findAdapterOfType` in interface `ComponentAdapter<T>`
  Type Parameters:
    `U` - the type of ComponentAdapter being located.
  Parameters:
    `componentAdapterType` - the class of the adapter type being located. Never null.
  Returns:
    the appropriate component adapter of type U. May return null if the component adapter type is not returned.

### getComponentInstance

    public T getComponentInstance(PicoContainer container)

  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>`
  Parameters:
    `container` - the `PicoContainer`, that is used to resolve any possible dependencies of the instance.
  Returns:
    the component instance.

### getComponentInstance

    public abstract T getComponentInstance(PicoContainer container,
                                           Type into)

  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>`
  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.

### 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>`
  Parameters:
    `container` - the container that can provide injectable dependencies
    `instance` - the instance to
  Returns:

### verify

    public void verify(PicoContainer container)

  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>`
  Parameters:
    `container` - the `PicoContainer`, that is used to resolve any possible dependencies of the instance.

### getDescriptor

    public String getDescriptor()

  Description copied from interface: `ComponentAdapter`
  Get a string key descriptor of the component adapter.

  Specified by:
    `getDescriptor` in interface `ComponentAdapter<T>`
  Returns:

### start

    public void start(PicoContainer container)

### stop

    public void stop(PicoContainer container)

### dispose

    public void dispose(PicoContainer container)

### componentHasLifecycle

    public boolean componentHasLifecycle()

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2003-2009 Codehaus. All Rights Reserved.