wired = null;    inBuffer.reset();    outBuffer.reset();    tail.reset(); // reset tail last  }  /**   * Convenience method that calls the method with same name and three   * arguments, using a byte array of length <code>1</code> whose contents are   * the designated byte.   *   * @param b the byte to process.   * @return the result of transformation.   * @throws IllegalStateException if the instance is not initialised.   * @throws TransformerException if a transformation-related exception occurs   * during the operation.   * @see #update(byte[], int, int)   */  public byte[] update(byte b) throws TransformerException  {    return update(new byte[] { b }, 0, 1);  }  /**   * Convenience method that calls the same method with three arguments. All   * bytes in <code>in</code>, starting from index position <code>0</code> are   * considered.   *   * @param in the input data bytes.   * @return the result of transformation.   * @throws IllegalStateException if the instance is not initialised.   * @throws TransformerException if a transformation-related exception occurs   * during the operation.   * @see #update(byte[], int, int)   */  public byte[] update(byte[] in) throws TransformerException  {    return update(in, 0, in.length);  }  /**   * Processes a designated number of bytes from a given byte array.   *   * @param in the input data bytes.   * @param offset index of <code>in</code> from which to start considering   * data.   * @param length the count of bytes to process.   * @return the result of transformation.   * @throws IllegalStateException if the instance is not initialised.   * @throws TransformerException if a transformation-related exception occurs   * during the operation.   */  public byte[] update(byte[] in, int offset, int length)      throws TransformerException  {    if (wired == null)      {        throw new IllegalStateException();      }    byte[] result = (wired == Direction.FORWARD ? forwardUpdate(in, offset,                                                                length)                                               : inverseUpdate(in, offset,                                                               length));    return result;  }  /**   * Convenience method that calls the same method with three arguments. A   * zero-long byte array is used.   *   * @return the result of transformation.   * @throws IllegalStateException if the instance is not initialised.   * @throws TransformerException if a transformation-related exception occurs   * during the operation.   * @see #lastUpdate(byte[], int, int)   */  public byte[] lastUpdate() throws TransformerException  {    byte[] result = (wired == Direction.FORWARD ? lastForwardUpdate()                                               : lastInverseUpdate());    if (inBuffer.size() != 0)      { // we still have some buffered bytes        throw new TransformerException("lastUpdate(): input buffer not empty");      }    return result;  }  /**   * Convenience method that calls the method with same name and three   * arguments, using a byte array of length <code>1</code> whose contents are   * the designated byte.   *   * @param b the byte to process.   * @return the result of transformation.   * @throws IllegalStateException if the instance is not initialised.   * @throws TransformerException if a transformation-related exception occurs   * during the operation.   * @see #lastUpdate(byte[], int, int)   */  public byte[] lastUpdate(byte b) throws TransformerException  {    return lastUpdate(new byte[] { b }, 0, 1);  }  /**   * Convenience method that calls the same method with three arguments. All   * bytes in <code>in</code>, starting from index position <code>0</code> are   * considered.   *   * @param in the input data bytes.   * @return the result of transformation.   * @throws IllegalStateException if the instance is not initialised.   * @throws TransformerException if a transformation-related exception occurs   * during the operation.   * @see #lastUpdate(byte[], int, int)   */  public byte[] lastUpdate(byte[] in) throws TransformerException  {    return lastUpdate(in, 0, in.length);  }  /**   * Processes a designated number of bytes from a given byte array and   * signals, at the same time, that this is the last <i>push</i> operation on   * this <code>Transformer</code>.   *   * @param in the input data bytes.   * @param offset index of <code>in</code> from which to start considering   * data.   * @param length the count of bytes to process.   * @return the result of transformation.   * @throws IllegalStateException if the instance is not initialised.   * @throws TransformerException if a transformation-related exception occurs   * during the operation.   */  public byte[] lastUpdate(byte[] in, int offset, int length)      throws TransformerException  {    byte[] result = update(in, offset, length);    byte[] rest = lastUpdate();    if (rest.length > 0)      {        byte[] newResult = new byte[result.length + rest.length];        System.arraycopy(result, 0, newResult, 0, result.length);        System.arraycopy(rest, 0, newResult, result.length, rest.length);        result = newResult;      }    return result;  }  // helper methods ----------------------------------------------------------  private byte[] forwardUpdate(byte[] in, int off, int len)      throws TransformerException  {    return (isPreProcessing() ? preTransform(in, off, len) : postTransform(in,                                                                           off,                                                                           len));  }  private byte[] inverseUpdate(byte[] in, int off, int len)      throws TransformerException  {    return (isPreProcessing() ? postTransform(in, off, len) : preTransform(in,                                                                           off,                                                                           len));  }  private byte[] preTransform(byte[] in, int off, int len)      throws TransformerException  {    byte[] result = updateDelegate(in, off, len);    result = tail.update(result);    return result;  }  private byte[] postTransform(byte[] in, int off, int len)      throws TransformerException  {    byte[] result = tail.update(in, off, len);    result = updateDelegate(result, 0, result.length);    return result;  }  private byte[] lastForwardUpdate() throws TransformerException  {    return (isPreProcessing() ? preLastTransform() : postLastTransform());  }  private byte[] lastInverseUpdate() throws TransformerException  {    return (isPreProcessing() ? postLastTransform() : preLastTransform());  }  private byte[] preLastTransform() throws TransformerException  {    byte[] result = lastUpdateDelegate();    result = tail.lastUpdate(result);    return result;  }  private byte[] postLastTransform() throws TransformerException  {    byte[] result = tail.lastUpdate();    result = updateDelegate(result, 0, result.length);    byte[] rest = lastUpdateDelegate();    if (rest.length > 0)      {        byte[] newResult = new byte[result.length + rest.length];        System.arraycopy(result, 0, newResult, 0, result.length);        System.arraycopy(rest, 0, newResult, result.length, rest.length);        result = newResult;      }    return result;  }  // abstract methods to be implemented by concrete subclasses ---------------  abstract void initDelegate(Map attributes) throws TransformerException;  abstract int delegateBlockSize();  abstract void resetDelegate();  abstract byte[] updateDelegate(byte[] in, int off, int len)      throws TransformerException;  abstract byte[] lastUpdateDelegate() throws TransformerException;}