org.eclipse.microprofile.reactive.streams.operators.spi

## Interface ReactiveStreamsEngine

    public interface ReactiveStreamsEngine

An engine for turning reactive streams graphs into Reactive Streams publishers/subscribers.

The zero argument `build` and `run` methods on subclasses of this will use the `ServiceLoader` to load an engine for the current context classloader. It does not cache engines between invocations. If instantiating an engine is expensive (eg, it creates threads), then it is recommended that the implementation does its own caching by providing the engine using a static provider method.

### Method Summary

All Methods Instance Methods Abstract Methods
`<T> CompletionStage<T>` `buildCompletion(Graph graph)` Build a closed graph from the given stages.
`<T,R> org.reactivestreams.Processor<T,R>` `buildProcessor(Graph graph)` Build a `Processor` from the given stages.
`<T> org.reactivestreams.Publisher<T>` `buildPublisher(Graph graph)` Build a `Publisher` from the given stages.
`<T,R> SubscriberWithCompletionStage<T,R>` `buildSubscriber(Graph graph)` Build a `Subscriber` from the given stages.

### Method Detail

#### buildPublisher

    <T> org.reactivestreams.Publisher<T> buildPublisher(Graph graph)
                                                 throws UnsupportedStageException

Build a `Publisher` from the given stages.

The passed in graph will have an outlet and no inlet.

Type Parameters:
  `T` - The type of elements that the publisher publishes.
Parameters:
  `graph` - The stages to build the publisher from. Will not be empty.
Returns:
  A publisher that implements the passed in graph of stages.
Throws:
  `UnsupportedStageException` - If a stage in the stages is not supported by this Reactive Streams engine.

#### buildSubscriber

    <T,R> SubscriberWithCompletionStage<T,R> buildSubscriber(Graph graph)
                                                      throws UnsupportedStageException

Build a `Subscriber` from the given stages.

The passed in graph will have an inlet and no outlet.

Type Parameters:
  `T` - The type of elements that the subscriber subscribes to.
  `R` - The result of subscribing to the stages.
Parameters:
  `graph` - The graph to build the subscriber from. Will not be empty.
Returns:
  A subscriber that implements the passed in graph of stages.
Throws:
  `UnsupportedStageException` - If a stage in the stages is not supported by this Reactive Streams engine.

#### buildProcessor

    <T,R> org.reactivestreams.Processor<T,R> buildProcessor(Graph graph)
                                                     throws UnsupportedStageException

Build a `Processor` from the given stages.

The passed in graph will have an inlet and an outlet.

Type Parameters:
  `T` - The type of elements that the processor subscribes to.
  `R` - The type of elements that the processor publishes.
Parameters:
  `graph` - The graph to build the processor from. If empty, then the processor should be an identity processor.
Returns:
  A processor that implements the passed in graph of stages.
Throws:
  `UnsupportedStageException` - If a stage in the stages is not supported by this Reactive Streams engine.

#### buildCompletion

    <T> CompletionStage<T> buildCompletion(Graph graph)
                                    throws UnsupportedStageException

Build a closed graph from the given stages.

The passed in graph will have no inlet and no outlet.

Type Parameters:
  `T` - The type of the result of running the closed graph.
Parameters:
  `graph` - The graph to build the closed graph from. Will not be empty.
Returns:
  A CompletionStage of the result of running the graph.
Throws:
  `UnsupportedStageException` - If a stage in the stages is not supported by this reactive streams engine.