Package org.picocontainer.adapters

# Class InstanceAdapter<T>

java.lang.Object
org.picocontainer.adapters.AbstractAdapter<T>
org.picocontainer.adapters.InstanceAdapter<T>

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

public final class InstanceAdapter<T> extends AbstractAdapter<T> implements ComponentLifecycle<T>, LifecycleStrategy

Component adapter which wraps a component instance.

This component adapter supports both a `Behavior` and a `LifecycleStrategy` to control the lifecycle of the component. The lifecycle manager methods simply delegate to the lifecycle strategy methods on the component instance.

Author:
  Aslak Hellesøy, Paul Hammant, Mauro Talevi
See Also:
  - Serialized Form

## Nested Class Summary

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

`ComponentAdapter.NOTHING`

## Constructor Summary

Constructors
Constructor
Description
`InstanceAdapter(Object componentKey, T componentInstance)`
`InstanceAdapter(Object componentKey, T componentInstance, ComponentMonitor componentMonitor)`
`InstanceAdapter(Object componentKey, T componentInstance, LifecycleStrategy lifecycleStrategy)`
`InstanceAdapter(Object componentKey, T componentInstance, LifecycleStrategy lifecycleStrategy, ComponentMonitor componentMonitor)`

## Method Summary

Modifier and Type
Method
Description
`boolean`
`componentHasLifecycle()`
Test if a component honors a lifecycle.
`void`
`dispose(Object component)`
Invoke the "dispose" method on the component instance if this is disposable.
`void`
`dispose(PicoContainer container)`
Invoke the "dispose" method on the component.
`T`
`getComponentInstance(PicoContainer container, Type into)`
Retrieve the component instance.
`String`
`getDescriptor()`
Get a string key descriptor of the component adapter for use in toString()
`boolean`
`hasLifecycle(Class<?> type)`
Test if a component instance has a lifecycle.
`boolean`
`isLazy(ComponentAdapter<?> adapter)`
Is a component eager (not lazy) in that it should start when start() or equivalent is called, or lazy (it will only start on first getComponent() ).
`boolean`
`isStarted()`
`void`
`start(Object component)`
Invoke the "start" method on the component instance if this is startable.
`void`
`start(PicoContainer container)`
Invoke the "start" method on the component.
`void`
`stop(Object component)`
Invoke the "stop" method on the component instance if this is stoppable.
`void`
`stop(PicoContainer container)`
Invoke the "stop" method on the component.
`String`
`toString()`
`void`
`verify(PicoContainer container)`
Verify that all dependencies for this adapter can be satisfied.

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

`accept, changeMonitor, checkTypeCompatibility, currentMonitor, findAdapterOfType, getComponentImplementation, getComponentInstance, getComponentKey, getDelegate`

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

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

## Constructor Details

### InstanceAdapter

public InstanceAdapter(Object componentKey, T componentInstance, LifecycleStrategy lifecycleStrategy, ComponentMonitor componentMonitor) throws PicoCompositionException

Throws:
  `PicoCompositionException`

### InstanceAdapter

public InstanceAdapter(Object componentKey, T componentInstance)

### InstanceAdapter

public InstanceAdapter(Object componentKey, T componentInstance, LifecycleStrategy lifecycleStrategy)

### InstanceAdapter

public InstanceAdapter(Object componentKey, T componentInstance, ComponentMonitor componentMonitor)

## Method Details

### getComponentInstance

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

### 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 for use in toString()

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

### toString

public String toString()

Overrides:
  `toString` in class `AbstractAdapter<T>`
Returns:
  Returns the ComponentAdapter's class name and the component's key.
See Also:
  - `Object.toString()`

### start

public void start(PicoContainer container)
Description copied from interface: `ComponentLifecycle`
Invoke the "start" method on the component.

Specified by:
  `start` in interface `ComponentLifecycle<T>`
Parameters:
  `container` - the container to "start" the component

### stop

public void stop(PicoContainer container)
Description copied from interface: `ComponentLifecycle`
Invoke the "stop" method on the component.

Specified by:
  `stop` in interface `ComponentLifecycle<T>`
Parameters:
  `container` - the container to "stop" the component

### dispose

public void dispose(PicoContainer container)
Description copied from interface: `ComponentLifecycle`
Invoke the "dispose" method on the component.

Specified by:
  `dispose` in interface `ComponentLifecycle<T>`
Parameters:
  `container` - the container to "dispose" the component

### componentHasLifecycle

public boolean componentHasLifecycle()
Description copied from interface: `ComponentLifecycle`
Test if a component honors a lifecycle.

Specified by:
  `componentHasLifecycle` in interface `ComponentLifecycle<T>`
Returns:
  `true` if the component has a lifecycle

### isStarted

public boolean isStarted()

Specified by:
  `isStarted` in interface `ComponentLifecycle<T>`

### start

public void start(Object component)
Description copied from interface: `LifecycleStrategy`
Invoke the "start" method on the component instance if this is startable. It is up to the implementation of the strategy what "start" and "startable" means.

Specified by:
  `start` in interface `LifecycleStrategy`
Parameters:
  `component` - the instance of the component to start

### stop

public void stop(Object component)
Description copied from interface: `LifecycleStrategy`
Invoke the "stop" method on the component instance if this is stoppable. It is up to the implementation of the strategy what "stop" and "stoppable" means.

Specified by:
  `stop` in interface `LifecycleStrategy`
Parameters:
  `component` - the instance of the component to stop

### dispose

public void dispose(Object component)
Description copied from interface: `LifecycleStrategy`
Invoke the "dispose" method on the component instance if this is disposable. It is up to the implementation of the strategy what "dispose" and "disposable" means.

Specified by:
  `dispose` in interface `LifecycleStrategy`
Parameters:
  `component` - the instance of the component to dispose

### hasLifecycle

public boolean hasLifecycle(Class<?> type)
Description copied from interface: `LifecycleStrategy`
Test if a component instance has a lifecycle.

Specified by:
  `hasLifecycle` in interface `LifecycleStrategy`
Parameters:
  `type` - the component's type
Returns:
  `true` if the component has a lifecycle

### isLazy

public boolean isLazy(ComponentAdapter<?> adapter)
Description copied from interface: `LifecycleStrategy`
Is a component eager (not lazy) in that it should start when start() or equivalent is called, or lazy (it will only start on first getComponent() ). The default is the first of those two.

Specified by:
  `isLazy` in interface `LifecycleStrategy`
Parameters:
  `adapter` -
Returns:
  true if lazy, false if not lazy