/**
   * Add a new Valve to the end of the pipeline associated with this Container. Prior to adding the
   * Valve, the Valve's <code>setContainer()</code> method will be called, if it implements <code>
   * Contained</code>, with the owning Container as an argument. The method may throw an <code>
   * IllegalArgumentException</code> if this Valve chooses not to be associated with this Container,
   * or <code>IllegalStateException</code> if it is already associated with a different Container.
   *
   * @param valve Valve to be added
   * @exception IllegalArgumentException if this Container refused to accept the specified Valve
   * @exception IllegalArgumentException if the specified Valve refuses to be associated with this
   *     Container
   * @exception IllegalStateException if the specified Valve is already associated with a different
   *     Container
   */
  @Override
  public void addValve(Valve valve) {

    // Validate that we can add this Valve
    if (valve instanceof Contained) ((Contained) valve).setContainer(this.container);

    // Start the new component if necessary
    if (getState().isAvailable()) {
      if (valve instanceof Lifecycle) {
        try {
          ((Lifecycle) valve).start();
        } catch (LifecycleException e) {
          log.error("StandardPipeline.addValve: start: ", e);
        }
      }
    }

    // Add this Valve to the set associated with this Pipeline
    if (first == null) {
      first = valve;
      valve.setNext(basic);
    } else {
      Valve current = first;
      while (current != null) {
        if (current.getNext() == basic) {
          current.setNext(valve);
          valve.setNext(basic);
          break;
        }
        current = current.getNext();
      }
    }

    container.fireContainerEvent(Container.ADD_VALVE_EVENT, valve);
  }
  /** Add Tomcat-style valve. */
  public synchronized void addValve(Valve valve) {

    /*
     * Check if this is a GlassFish-style valve that was compiled
     * against the old org.apache.catalina.Valve interface (from
     * GlassFish releases prior to V3), which has since been renamed
     * to org.glassfish.web.valve.GlassFishValve (in V3)
     */
    if (isGlassFishValve(valve)) {
      try {
        addValve(new GlassFishValveAdapter(valve));
      } catch (Exception e) {
        String msg = MessageFormat.format(rb.getString(ADD_TOMCAT_STYLE_VALVE_EXCEPTION), valve);
        log.log(Level.SEVERE, msg, e);
      }
      return;
    }

    if (valve instanceof Contained) ((Contained) valve).setContainer(this.container);

    // Start the new Valve if necessary
    if (started) {
      if (valve instanceof Lifecycle) {
        try {
          ((Lifecycle) valve).start();
        } catch (LifecycleException e) {
          log.log(Level.SEVERE, ADD_VALVE_EXCEPTION, e);
        }
      }
    }

    if (firstTcValve == null) {
      firstTcValve = lastTcValve = valve;
    } else {
      lastTcValve.setNext(valve);
      lastTcValve = valve;
    }

    if (basic != null) {
      valve.setNext((Valve) basic);
    }
  }
  /**
   * 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 <code>setContainer()</code> will be called,
   * if it implements <code>Contained</code>, with the owning Container as an argument. The method
   * may throw an <code>IllegalArgumentException</code> if this Valve chooses not to be associated
   * with this Container, or <code>IllegalStateException</code> if it is already associated with a
   * different Container.
   *
   * @param valve Valve to be distinguished as the basic Valve
   */
  @Override
  public void setBasic(Valve valve) {

    // Change components if necessary
    Valve oldBasic = this.basic;
    if (oldBasic == valve) return;

    // Stop the old component if necessary
    if (oldBasic != null) {
      if (getState().isAvailable() && (oldBasic instanceof Lifecycle)) {
        try {
          ((Lifecycle) oldBasic).stop();
        } catch (LifecycleException e) {
          log.error("StandardPipeline.setBasic: stop", e);
        }
      }
      if (oldBasic instanceof Contained) {
        try {
          ((Contained) oldBasic).setContainer(null);
        } catch (Throwable t) {
          ExceptionUtils.handleThrowable(t);
        }
      }
    }

    // Start the new component if necessary
    if (valve == null) return;
    if (valve instanceof Contained) {
      ((Contained) valve).setContainer(this.container);
    }
    if (getState().isAvailable() && valve instanceof Lifecycle) {
      try {
        ((Lifecycle) valve).start();
      } catch (LifecycleException e) {
        log.error("StandardPipeline.setBasic: start", e);
        return;
      }
    }

    // Update the pipeline
    Valve current = first;
    while (current != null) {
      if (current.getNext() == oldBasic) {
        current.setNext(valve);
        break;
      }
      current = current.getNext();
    }

    this.basic = valve;
  }
  /**
   * 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 <code>setContainer(null)
   * </code> method will be called if it implements <code>Contained</code>.
   *
   * @param valve Valve to be removed
   */
  @Override
  public void removeValve(Valve valve) {

    Valve current;
    if (first == valve) {
      first = first.getNext();
      current = null;
    } else {
      current = first;
    }
    while (current != null) {
      if (current.getNext() == valve) {
        current.setNext(valve.getNext());
        break;
      }
      current = current.getNext();
    }

    if (first == basic) first = null;

    if (valve instanceof Contained) ((Contained) valve).setContainer(null);

    // Stop this valve if necessary
    if (getState().isAvailable()) {
      if (valve instanceof Lifecycle) {
        try {
          ((Lifecycle) valve).stop();
        } catch (LifecycleException e) {
          log.error("StandardPipeline.removeValve: stop: ", e);
        }
      }
    }
    try {
      ((Lifecycle) valve).destroy();
    } catch (LifecycleException e) {
      log.error("StandardPipeline.removeValve: destroy: ", e);
    }

    container.fireContainerEvent(Container.REMOVE_VALVE_EVENT, valve);
  }