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.behaviors
Class AbstractBehavior<T>

    java.lang.Object
      org.picocontainer.behaviors.AbstractBehavior<T>

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

Direct Known Subclasses:
  Automated, Decorated, FieldDecorated, Guarded, HiddenImplementation, Locked, PropertyApplicator, Stored, Synchronized

    public abstract class AbstractBehavior<T>

extends Object
implements Behavior<T>, ComponentMonitorStrategy, LifecycleStrategy, Serializable

Component adapter which decorates another adapter.

This adapter supports a `component monitor strategy` and will propagate change of monitor to the delegate if the delegate itself support the monitor strategy.

This adapter also supports a `lifecycle manager` and a `lifecycle strategy` if the delegate does.

Author:
  Jon Tirsen, Aslak Hellesoy, Mauro Talevi
See Also:
  Serialized Form

Nested Class Summary

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

Field Summary
`protected ComponentAdapter<T>` | `delegate`

Constructor Summary
`AbstractBehavior(ComponentAdapter<T> delegate)`

Method Summary
`void` | `accept(PicoVisitor visitor)` Accepts a visitor for this ComponentAdapter.
`void` | `changeMonitor(ComponentMonitor monitor)` Delegates change of monitor if the delegate supports a component monitor strategy.
`boolean` | `componentHasLifecycle()` Invokes delegate hasLifecycle method if the delegate is a Behavior Test if a component honors a lifecycle.
`ComponentMonitor` | `currentMonitor()` Returns delegate's current monitor if the delegate supports a component monitor strategy.
`void` | `dispose(Object component)` Invokes delegate dispose method if the delegate is a LifecycleStrategy Invoke the "dispose" method on the component instance if this is disposable.
`void` | `dispose(PicoContainer container)` Invokes delegate dispose method if the delegate is a Behavior Invoke the "dispose" method on the component.
`
`<U extends ComponentAdapter> U`
` | `findAdapterOfType(Class<U> componentAdapterType)` Locates a component adapter of type componentAdapterType in the ComponentAdapter chain.
`Class<T>` | `getComponentImplementation()` Retrieve the class of the component.
`T` | `getComponentInstance(PicoContainer container)` Retrieve the component instance.
`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.
`boolean` | `hasLifecycle(Class<?> type)` Invokes delegate hasLifecycle(Class) method if the delegate is a LifecycleStrategy Test if a component instance has a lifecycle.
`boolean` | `isStarted()`
`void` | `start(Object component)` Invokes delegate start method if the delegate is a LifecycleStrategy Invoke the "start" method on the component instance if this is startable.
`void` | `start(PicoContainer container)` Invokes delegate start method if the delegate is a Behavior Invoke the "start" method on the component.
`void` | `stop(Object component)` Invokes delegate stop method if the delegate is a LifecycleStrategy Invoke the "stop" method on the component instance if this is stoppable.
`void` | `stop(PicoContainer container)` Invokes delegate stop method if the delegate is a Behavior 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 java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Methods inherited from interface org.picocontainer.ComponentAdapter
`getDescriptor`

Field Detail

### delegate

    protected final ComponentAdapter<T> delegate

Constructor Detail

### AbstractBehavior

    public AbstractBehavior(ComponentAdapter<T> delegate)

Method Detail

### 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).

### getComponentInstance

    public T getComponentInstance(PicoContainer container)
                           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>`
  Parameters:
    `container` - the `PicoContainer`, that is used to resolve any possible dependencies of the instance.
  Returns:
    the component instance.
  Throws:
    `PicoCompositionException` - if the component has dependencies which could not be resolved, or instantiation of the component lead to an ambigous situation within the container.

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

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

### getDelegate

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

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

### changeMonitor

    public void changeMonitor(ComponentMonitor monitor)

  Delegates change of monitor if the delegate supports a component monitor strategy. Changes the component monitor used

  Specified by:
    `changeMonitor` in interface `ComponentMonitorStrategy`
  Parameters:
    `monitor` - the new ComponentMonitor to use

### currentMonitor

    public ComponentMonitor currentMonitor()

  Returns delegate's current monitor if the delegate supports a component monitor strategy. Returns the monitor currently used

  Specified by:
    `currentMonitor` in interface `ComponentMonitorStrategy`
  Returns:
    The ComponentMonitor currently used
  Throws:
    `PicoCompositionException` - if no component monitor is found in delegate

### start

    public void start(PicoContainer container)

  Invokes delegate start method if the delegate is a Behavior 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)

  Invokes delegate stop method if the delegate is a Behavior 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)

  Invokes delegate dispose method if the delegate is a Behavior 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()

  Invokes delegate hasLifecycle method if the delegate is a Behavior 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)

  Invokes delegate start method if the delegate is a 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)

  Invokes delegate stop method if the delegate is a 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)

  Invokes delegate dispose method if the delegate is a 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)

  Invokes delegate hasLifecycle(Class) method if the delegate is a 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

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

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.