You have a series of transformations and you need to chain them together, passing the output of one stage to the input of the next.

Create multiple implementations of Transformer, and chain them together with ChainedTransformer. A ChainedTransformer takes an array of Transformer objects, passing the output of each Transformer to the next Transformer in the chain. The following example demonstrates a ChainedTransformer with two Transformer stages. The first stage, multiply, multiplies a number by 100, and the second stage, increment, adds one to the result from the first stage:

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
Transformer multiply = new Transformer( ) {
    public Object transform(Object input) {
                Long number = (Long) input;
         return( new Long( number.longValue( ) * 100 ) );
        }
}
Transformer increment = new Transformer( ) {
    public Object transform(Object input) {
                Long number = (Long) input;
         return( new Long( number.longValue( ) + 1 ) );
        }
}
Transformer[] chainElements = new Transformer[] { multiply, increment };
Transformer chain = new ChainedTransformer( chainElements );
Long original = new Long( 34 );
Long result = chain.transform( original );
System.out.println( "Original: " + original );
System.out.println( "Result: " + result );

The Transformer chain takes the Long instance original and transforms it into a result:

Original: 34
Result: 3401

Since a Transformer leaves the input parameter passed to transform( ) intact, this two-stage ChainedTransformer creates a new instance of Long for each stage in the ChainedTransformer. A Long is passed to the first stage, multiply, which transforms 34 to 3400. The result from the first stage, 3400, is then passed to the second stage, increment, which produces the final Long result, 3401. A real example would involve more complex implementations of Transformer, but this simple example demonstrates the mechanics of creating a simple pipeline of transformations, one leading to another. Figure 4-4 illustrates the simple structure of this two-staged ChainedTransformer.

Figure 4-4. A ChainedTransformer with two Transformers