trjhtr

I have several "computation pipelines" that share the same purpose and number of steps, even if the step implementations and the classes of the the intermediate values that are passed between them are different for each pipeline. For example, they might be

$$
newcommandptr[1]oversetmathtt#1longrightarrow
textttRequest ptrstep 1 A ptrstep 2 textttResponse
$$

or

$$
textttRequest ptrstep 1 B ptrstep 2 textttResponse
$$

The start and end of the pipelines are always the same.

I want to avoid duplicating the common "interstitial code" between the steps,
which may do things like logging or error handling. I also want to ensure that:

• Implementation inheritance is not used. This appears to rule out the "template method" pattern.


• Type safety is maintained, in the sense that step implementations should not have to downcast an intermediate value at any point.

I came up with the following solution. First, a generic Pipeline interface, parameterized with the type of the intermediate values and with one method for each step:

public interface Pipeline<A> 

 A step1(Request request);

 Response step2(A intermediate);

Second, a Runner class that is ignorant of the exact type of the intermediate steps:

public final class Runner 

 private final Pipeline<?> pipeline;

 public Runner(Pipeline<?> pipeline) 
 super();
 this.pipeline = pipeline;
 

 public Response runPipeline(Request request) 
 // This doesn't fly, wildcard trouble 
 // return pipeline.step2(pipeline.step1(request)); 

 // With the helper it works
 return runPipeline(request,pipeline);
 

 // wildcard capture helper
 public static <A> Response runPipeline(Request request, Pipeline<A> pipeline) 
 A intermediate = pipeline.step1(request);
 //
 // shared interstitial code here 
 //
 return pipeline.step2(intermediate);
 

Is there a better way of doing this? Does this type of solution have a name, is it used anywhere else?