# Class StandardPipeline

java.lang.Object
org.apache.catalina.util.LifecycleBase
org.apache.catalina.core.StandardPipeline

All Implemented Interfaces:
  `Contained, Lifecycle, Pipeline`

public class StandardPipeline extends LifecycleBase implements Pipeline
Standard implementation of a processing Pipeline that will invoke a series of Valves that have been configured to be called in order. This implementation can be used for any type of Container. IMPLEMENTATION WARNING - This implementation assumes that no calls to `addValve()` or `removeValve` are allowed while a request is currently being processed. Otherwise, the mechanism by which per-thread state is maintained will need to be modified.

- ## Nested Class Summary

  ### Nested classes/interfaces inherited from interface Lifecycle

  `Lifecycle.SingleUse`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected Valve`
  `basic`
  The basic Valve (if any) associated with this Pipeline.
  `protected Container`
  `container`
  The Container with which this Pipeline is associated.
  `protected Valve`
  `first`
  The first valve associated with this Pipeline.

  ### Fields inherited from interface Lifecycle

  `AFTER_DESTROY_EVENT, AFTER_INIT_EVENT, AFTER_START_EVENT, AFTER_STOP_EVENT, BEFORE_DESTROY_EVENT, BEFORE_INIT_EVENT, BEFORE_START_EVENT, BEFORE_STOP_EVENT, CONFIGURE_START_EVENT, CONFIGURE_STOP_EVENT, PERIODIC_EVENT, START_EVENT, STOP_EVENT`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `StandardPipeline()`
  Construct a new StandardPipeline instance with no associated Container.
  `StandardPipeline(Container container)`
  Construct a new StandardPipeline instance that is associated with the specified Container.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `addValve(Valve valve)`
  Add a new Valve to the end of the pipeline associated with this Container.
  `protected void`
  `destroyInternal()`
  Subclasses implement this method to perform any instance destruction required.
  `void`
  `findNonAsyncValves(Set<String> result)`
  Identifies the Valves, if any, in this Pipeline that do not support async.
  `Valve`
  `getBasic()`
  `Container`
  `getContainer()`
  Get the `Container` with which this instance is associated.
  `Valve`
  `getFirst()`
  `ObjectName[]`
  `getValveObjectNames()`
  `Valve[]`
  `getValves()`
  `protected void`
  `initInternal()`
  Subclasses implement this method to perform any instance initialisation required.
  `boolean`
  `isAsyncSupported()`
  Returns true if all the valves in this pipeline support async, false otherwise
  `void`
  `removeValve(Valve valve)`
  Remove the specified Valve from the pipeline associated with this Container, if it is found; otherwise, do nothing.
  `void`
  `setBasic(Valve valve)`
  Set the Valve instance that has been distinguished as the basic Valve for this Pipeline (if any).
  `void`
  `setContainer(Container container)`
  Set the `Container` with which this instance is associated.
  `protected void`
  `startInternal()`
  Subclasses must ensure that the state is changed to `LifecycleState.STARTING` during the execution of this method.
  `protected void`
  `stopInternal()`
  Subclasses must ensure that the state is changed to `LifecycleState.STOPPING` during the execution of this method.
  `String`
  `toString()`

  ### Methods inherited from class LifecycleBase

  `addLifecycleListener, destroy, findLifecycleListeners, fireLifecycleEvent, getState, getStateName, getThrowOnFailure, init, removeLifecycleListener, setState, setState, setThrowOnFailure, start, stop`

  ### Methods inherited from class Object

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

- ## Field Details

  - ### basic

    protected Valve basic
    The basic Valve (if any) associated with this Pipeline.

  - ### container

    protected Container container
    The Container with which this Pipeline is associated.

  - ### first

    protected Valve first
    The first valve associated with this Pipeline.

- ## Constructor Details

  - ### StandardPipeline

    public StandardPipeline()
    Construct a new StandardPipeline instance with no associated Container.

  - ### StandardPipeline

    public StandardPipeline(Container container)
    Construct a new StandardPipeline instance that is associated with the specified Container.
    Parameters:
      `container` - The container we should be associated with

- ## Method Details

  - ### isAsyncSupported

    public boolean isAsyncSupported()
    Description copied from interface: `Pipeline`
    Returns true if all the valves in this pipeline support async, false otherwise
    Specified by:
      `isAsyncSupported` in interface `Pipeline`
    Returns:
      true if all the valves in this pipeline support async, false otherwise

  - ### findNonAsyncValves

    public void findNonAsyncValves(Set<String> result)
    Description copied from interface: `Pipeline`
    Identifies the Valves, if any, in this Pipeline that do not support async.
    Specified by:
      `findNonAsyncValves` in interface `Pipeline`
    Parameters:
      `result` - The Set to which the fully qualified class names of each Valve in this Pipeline that does not support async will be added

  - ### getContainer

    public Container getContainer()
    Description copied from interface: `Contained`
    Get the `Container` with which this instance is associated.
    Specified by:
      `getContainer` in interface `Contained`
    Returns:
      The Container with which this instance is associated or `null` if not associated with a Container

  - ### setContainer

    public void setContainer(Container container)
    Description copied from interface: `Contained`
    Set the `Container` with which this instance is associated.
    Specified by:
      `setContainer` in interface `Contained`
    Parameters:
      `container` - The Container instance with which this instance is to be associated, or `null` to disassociate this instance from any Container

  - ### initInternal

    protected void initInternal()
    Description copied from class: `LifecycleBase`
    Subclasses implement this method to perform any instance initialisation required.
    Specified by:
      `initInternal` in class `LifecycleBase`

  - ### startInternal

    protected void startInternal() throws LifecycleException
    Description copied from class: `LifecycleBase`
    Subclasses must ensure that the state is changed to `LifecycleState.STARTING` during the execution of this method. Changing state will trigger the `Lifecycle.START_EVENT` event. If a component fails to start it may either throw a `LifecycleException` which will cause it's parent to fail to start, or it can place itself in the error state in which case `LifecycleBase.stop()` will be called on the failed component but the parent component will continue to start normally.
    Specified by:
      `startInternal` in class `LifecycleBase`
    Throws:
      `LifecycleException` - Start error occurred

  - ### stopInternal

    protected void stopInternal() throws LifecycleException
    Description copied from class: `LifecycleBase`
    Subclasses must ensure that the state is changed to `LifecycleState.STOPPING` during the execution of this method. Changing state will trigger the `Lifecycle.STOP_EVENT` event.
    Specified by:
      `stopInternal` in class `LifecycleBase`
    Throws:
      `LifecycleException` - Stop error occurred

  - ### destroyInternal

    protected void destroyInternal()
    Description copied from class: `LifecycleBase`
    Subclasses implement this method to perform any instance destruction required.
    Specified by:
      `destroyInternal` in class `LifecycleBase`

  - ### toString

    public String toString()
    Overrides:
      `toString` in class `Object`

  - ### getBasic

    public Valve getBasic()
    Specified by:
      `getBasic` in interface `Pipeline`
    Returns:
      the Valve instance that has been distinguished as the basic Valve for this Pipeline (if any).

  - ### setBasic

    public void setBasic(Valve valve)
    Description copied from interface: `Pipeline`

    Set the Valve instance that has been distinguished as the basic Valve for this Pipeline (if any). Prior to setting the basic Valve, the Valve's `setContainer()` will be called, if it implements `Contained`, with the owning Container as an argument. The method may throw an `IllegalArgumentException` if this Valve chooses not to be associated with this Container, or `IllegalStateException` if it is already associated with a different Container.

    Specified by:
      `setBasic` in interface `Pipeline`
    Parameters:
      `valve` - Valve to be distinguished as the basic Valve

  - ### addValve

    public void addValve(Valve valve)
    Description copied from interface: `Pipeline`

    Add a new Valve to the end of the pipeline associated with this Container. Prior to adding the Valve, the Valve's `setContainer()` method will be called, if it implements `Contained`, with the owning Container as an argument. The method may throw an `IllegalArgumentException` if this Valve chooses not to be associated with this Container, or `IllegalStateException` if it is already associated with a different Container.

    Implementation note: Implementations are expected to trigger the `Container.ADD_VALVE_EVENT` for the associated container if this call is successful.

    Specified by:
      `addValve` in interface `Pipeline`
    Parameters:
      `valve` - Valve to be added

  - ### getValves

    public Valve[] getValves()
    Specified by:
      `getValves` in interface `Pipeline`
    Returns:
      the array of Valves in the pipeline associated with this Container, including the basic Valve (if any). If there are no such Valves, a zero-length array is returned.

  - ### getValveObjectNames

    public ObjectName[] getValveObjectNames()

  - ### removeValve

    public void removeValve(Valve valve)
    Description copied from interface: `Pipeline`
    Remove the specified Valve from the pipeline associated with this Container, if it is found; otherwise, do nothing. If the Valve is found and removed, the Valve's `setContainer(null)` method will be called if it implements `Contained`.

    Implementation note: Implementations are expected to trigger the `Container.REMOVE_VALVE_EVENT` for the associated container if this call is successful.

    Specified by:
      `removeValve` in interface `Pipeline`
    Parameters:
      `valve` - Valve to be removed

  - ### getFirst

    public Valve getFirst()
    Specified by:
      `getFirst` in interface `Pipeline`
    Returns:
      the Valve instance that has been distinguished as the basic Valve for this Pipeline (if any).