For the latest news and information visit The GNU Crypto project

## gnu.crypto.assembly
Class Assembly

    java.lang.Object
      |
      +--gnu.crypto.assembly.Assembly

public class Assembly
extends java.lang.Object

An `Assembly` is a construction consisting of a chain of `Transformer` elements; each wired in pre- or post- transformation mode. This chain is terminated by one `LoopbackTransformer` element.

Once constructed, and correctly initialised, the bulk of the methods available on the `Assembly` are delegated to the head of the `Transformer` chain of the `Assembly`.

See Also:
  `Transformer`

Field Summary
`static java.lang.String` `DIRECTION`

Constructor Summary
`Assembly()` Trivial constructor that sets the chain to a `LoopbackTransformer`.

Method Summary
`void` `addPostTransformer(Transformer t)` Adds the designated `Transformer` and signals that it should operate in post-processing mode; i.e.
`void` `addPreTransformer(Transformer t)` Adds the designated `Transformer` and signals that it should operate in pre-processing mode; i.e.
`void` `init(java.util.Map attributes)` Initialises the `Assembly` for operation with specific characteristics.
`byte[]` `lastUpdate()` Convenience method that calls the method with same name and three arguments using a 0-long byte array.
`byte[]` `lastUpdate(byte b)` Convenience method that calls the method with same name and three arguments, using a byte array of length `1` whose contents are the designated byte.
`byte[]` `lastUpdate(byte[] in)` Convenience method that calls the method with same name and three arguments.
`byte[]` `lastUpdate(byte[] in, int offset, int length)` Processes a designated number of bytes from a given byte array and signals, at the same time, that this is the last push operation for this `Assembly`.
`void` `reset()` Resets the `Assembly` for re-initialisation and use with other characteristics.
`byte[]` `update(byte b)` Convenience method that calls the method with same name and three arguments, using a byte array of length `1` whose contents are the designated byte.
`byte[]` `update(byte[] in)` Convenience method that calls the method with same name and three arguments.
`byte[]` `update(byte[] in, int offset, int length)` Processes a designated number of bytes from a given byte array.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### DIRECTION

    public static final java.lang.String DIRECTION

See Also:
  Constant Field Values

Constructor Detail

### Assembly

    public Assembly()

  Trivial constructor that sets the chain to a `LoopbackTransformer`.

Method Detail

### addPreTransformer

    public void addPreTransformer(Transformer t)

  Adds the designated `Transformer` and signals that it should operate in pre-processing mode; i.e. it should apply its internal transformation algorithm on the input data stream, before it passes that stream to the next element in the chain.

  Parameters:
    `t` - the `Transformer` to add at the head of the current chain.
  Throws:
    `java.lang.IllegalArgumentException` - if the designated `Transformer` has a non-null tail; i.e. it is already an element of a chain.

### addPostTransformer

    public void addPostTransformer(Transformer t)

  Adds the designated `Transformer` and signals that it should operate in post-processing mode; i.e. it should apply its internal transformation algorithm on the input data stream, after it passes that stream to the next element in the chain.

  Parameters:
    `t` - the `Transformer` to add at the head of the current chain.
  Throws:
    `java.lang.IllegalArgumentException` - if the designated `Transformer` has a non-null tail; i.e. it is already an element of a chain.

### init

    public void init(java.util.Map attributes)
              throws TransformerException

  Initialises the `Assembly` for operation with specific characteristics.

  Parameters:
    `attributes` - a set of name-value pairs that describes the desired future behaviour of this instance.
  Throws:
    `java.lang.IllegalStateException` - if the instance is already initialised.
    `TransformerException`

### reset

    public void reset()

  Resets the `Assembly` for re-initialisation and use with other characteristics. This method always succeeds.

### update

    public byte[] update(byte b)
                  throws TransformerException

  Convenience method that calls the method with same name and three arguments, using a byte array of length `1` whose contents are the designated byte.

  Parameters:
    `b` - the byte to process.
  Returns:
    the result of transformation.
  Throws:
    `java.lang.IllegalStateException` - if the instance is not initialised.
    `TransformerException` - if a transformation-related exception occurs during the operation.
  See Also:
    `update(byte[], int, int)`

### update

    public byte[] update(byte[] in)
                  throws TransformerException

  Convenience method that calls the method with same name and three arguments. All bytes in `in`, starting from index position `0` are considered.

  Parameters:
    `in` - the input data bytes.
  Returns:
    the result of transformation.
  Throws:
    `java.lang.IllegalStateException` - if the instance is not initialised.
    `TransformerException` - if a transformation-related exception occurs during the operation.
  See Also:
    `update(byte[], int, int)`

### update

    public byte[] update(byte[] in,
                         int offset,
                         int length)
                  throws TransformerException

  Processes a designated number of bytes from a given byte array.

  Parameters:
    `in` - the input data bytes.
    `offset` - index of `in` from which to start considering data.
    `length` - the count of bytes to process.
  Returns:
    the result of transformation.
  Throws:
    `java.lang.IllegalStateException` - if the instance is not initialised.
    `TransformerException` - if a transformation-related exception occurs during the operation.

### lastUpdate

    public byte[] lastUpdate()
                      throws TransformerException

  Convenience method that calls the method with same name and three arguments using a 0-long byte array.

  Returns:
    the result of transformation.
  Throws:
    `java.lang.IllegalStateException` - if the instance is not initialised.
    `TransformerException` - if a transformation-related exception occurs during the operation.
  See Also:
    `lastUpdate(byte[], int, int)`

### lastUpdate

    public byte[] lastUpdate(byte b)
                      throws TransformerException

  Convenience method that calls the method with same name and three arguments, using a byte array of length `1` whose contents are the designated byte.

  Parameters:
    `b` - the byte to process.
  Returns:
    the result of transformation.
  Throws:
    `java.lang.IllegalStateException` - if the instance is not initialised.
    `TransformerException` - if a transformation-related exception occurs during the operation.
  See Also:
    `lastUpdate(byte[], int, int)`

### lastUpdate

    public byte[] lastUpdate(byte[] in)
                      throws TransformerException

  Convenience method that calls the method with same name and three arguments. All bytes in `in`, starting from index position `0` are considered.

  Parameters:
    `in` - the input data bytes.
  Returns:
    the result of transformation.
  Throws:
    `java.lang.IllegalStateException` - if the instance is not initialised.
    `TransformerException` - if a transformation-related exception occurs during the operation.
  See Also:
    `lastUpdate(byte[], int, int)`

### lastUpdate

    public byte[] lastUpdate(byte[] in,
                             int offset,
                             int length)
                      throws TransformerException

  Processes a designated number of bytes from a given byte array and signals, at the same time, that this is the last push operation for this `Assembly`.

  Parameters:
    `in` - the input data bytes.
    `offset` - index of `in` from which to start considering data.
    `length` - the count of bytes to process.
  Returns:
    the result of transformation.
  Throws:
    `java.lang.IllegalStateException` - if the instance is not initialised.
    `TransformerException` - if a transformation-related exception occurs during the operation.

For the latest news and information visit The GNU Crypto project

Copyright © 2001, 2002, 2003, 2004 Free Software Foundation, Inc.