com.github.fge.jsonschema.processing

Class ProcessorChain<IN extends MessageProvider,OUT extends MessageProvider>

java.lang.Object

com.github.fge.jsonschema.processing.ProcessorChain<IN,OUT>

Type Parameters:

IN - the input type for that chain

OUT - the output type for that chain

All Implemented Interfaces:

Processor<IN,OUT>

public final class ProcessorChain<IN extends MessageProvider,OUT extends MessageProvider>
extends Object
implements Processor<IN,OUT>

A processor chain

This class allows to build a chain out of different Processor instances. The result behaves like a processor itself, so it can be used in other chains as well.

Sample usage:

     final Processor<X, Y> chain = ProcessorChain.startWith(p1)
         .chainWith(p2).chainWith(...);

     // input is of type X
     final Y ret = chain.process(report, X);
 

Method Summary

Methods

Modifier and Type	Method and Description
<NEWOUT extends MessageProvider> ProcessorChain<IN,NEWOUT>	chainWith(Processor<OUT,NEWOUT> p2) Add an existing processor to that chain
Processor<IN,OUT>	end()
ProcessorChain<IN,OUT>	failOnError()
OUT	process(ProcessingReport report, IN input) Process the input
static <X extends MessageProvider> ProcessorChain<X,X>	start()
static <X extends MessageProvider,Y extends MessageProvider> ProcessorChain<X,Y>	startWith(Processor<X,Y> p) Start a processing chain with a single processor

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

startWith

public static <X extends MessageProvider,Y extends MessageProvider> ProcessorChain<X,Y> startWith(Processor<X,Y> p)

Start a processing chain with a single processor

Type Parameters:

X - the input type

Y - the output type

Parameters:

p - the processor

Returns:

a single element processing chain

start

public static <X extends MessageProvider> ProcessorChain<X,X> start()

failOnError

public ProcessorChain<IN,OUT> failOnError()

chainWith

public <NEWOUT extends MessageProvider> ProcessorChain<IN,NEWOUT> chainWith(Processor<OUT,NEWOUT> p2)

Add an existing processor to that chain

Note that this returns a new chain.

Type Parameters:

NEWOUT - the return type for that new processor

Parameters:

p2 - the processor to add

Returns:

a new chain consisting of the previous chain with the new processor appended

end

public Processor<IN,OUT> end()

process

public OUT process(ProcessingReport report,
          IN input)
                                    throws ProcessingException

Description copied from interface: Processor

Process the input

Specified by:

process in interface Processor<IN extends MessageProvider,OUT extends MessageProvider>

Parameters:

report - the report to use while processing

input - the input for this processor

Returns:

the output

Throws:

ProcessingException - processing failed