play.libs.streams

Class Accumulator<E,A>

java.lang.Object

play.libs.streams.Accumulator<E,A>

public abstract class Accumulator<E,A>
extends java.lang.Object

Accumulates inputs asynchronously into an output value. An accumulator is a view over an Akka streams Sink that materialises to a future, that is focused on the value of that future, rather than the Stream. This means methods such as map, recover and so on are provided for the eventually redeemed future value. In order to be in line with the Java ecosystem, the future implementation that this uses for the materialised value of the Sink is java.util.concurrent.CompletionStage, and running this accumulator will yield a CompletionStage. The constructor allows an accumulator to be created from such a sink. Many methods in the Akka streams API however materialise a scala.concurrent.Future, hence the fromSink method is provided to create an accumulator from a typical Akka streams Sink.

Method Summary

Modifier and Type	Method and Description
abstract play.api.libs.streams.Accumulator<E,A>	asScala() Convert this accumulator to a Scala accumulator.
static <E,A> Accumulator<E,A>	done(A a) Create a done accumulator with the given value.
static <E,A> Accumulator<E,A>	done(java.util.concurrent.CompletionStage<A> a) Create a done accumulator with the given future.
static <E,A> Accumulator<E,A>	fromSink(akka.stream.javadsl.Sink<E,java.util.concurrent.CompletionStage<A>> sink) Create an accumulator from an Akka streams sink.
abstract <B> Accumulator<E,B>	map(java.util.function.Function<? super A,? extends B> f, java.util.concurrent.Executor executor) Map the accumulated value.
abstract <B> Accumulator<E,B>	mapFuture(java.util.function.Function<? super A,? extends java.util.concurrent.CompletionStage<B>> f, java.util.concurrent.Executor executor) Map the accumulated value with a function that returns a future.
abstract Accumulator<E,A>	recover(java.util.function.Function<? super java.lang.Throwable,? extends A> f, java.util.concurrent.Executor executor) Recover from any errors encountered by the accumulator.
abstract Accumulator<E,A>	recoverWith(java.util.function.Function<? super java.lang.Throwable,? extends java.util.concurrent.CompletionStage<A>> f, java.util.concurrent.Executor executor) Recover from any errors encountered by the accumulator.
abstract java.util.concurrent.CompletionStage<A>	run(akka.stream.Materializer mat) Run the accumulator with an empty source.
abstract java.util.concurrent.CompletionStage<A>	run(akka.stream.javadsl.Source<E,?> source, akka.stream.Materializer mat) Run the accumulator with the given source.
static <E> Accumulator<E,akka.stream.javadsl.Source<E,?>>	source() Create an accumulator that forwards the stream fed into it to the source it produces.
abstract <D> Accumulator<D,A>	through(akka.stream.javadsl.Flow<D,E,?> flow) Pass the stream through the given flow before forwarding it to the accumulator.
abstract akka.stream.javadsl.Sink<E,java.util.concurrent.CompletionStage<A>>	toSink() Convert this accumulator to a sink.

Methods inherited from class java.lang.Object

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

Method Detail

map

public abstract <B> Accumulator<E,B> map(java.util.function.Function<? super A,? extends B> f,
                                         java.util.concurrent.Executor executor)

Map the accumulated value.

Parameters:

f - The function to perform the map with.

executor - The executor to run the function in.

Returns:

A new accumulator with the mapped value.

mapFuture

public abstract <B> Accumulator<E,B> mapFuture(java.util.function.Function<? super A,? extends java.util.concurrent.CompletionStage<B>> f,
                                               java.util.concurrent.Executor executor)

Map the accumulated value with a function that returns a future.

Parameters:

f - The function to perform the map with.

executor - The executor to run the function in.

Returns:

A new accumulator with the mapped value.

recover

public abstract Accumulator<E,A> recover(java.util.function.Function<? super java.lang.Throwable,? extends A> f,
                                         java.util.concurrent.Executor executor)

Recover from any errors encountered by the accumulator.

Parameters:

f - The function to use to recover from errors.

executor - The executor to run the function in.

Returns:

A new accumulator that has recovered from errors.

recoverWith

public abstract Accumulator<E,A> recoverWith(java.util.function.Function<? super java.lang.Throwable,? extends java.util.concurrent.CompletionStage<A>> f,
                                             java.util.concurrent.Executor executor)

Recover from any errors encountered by the accumulator.

Parameters:

f - The function to use to recover from errors.

executor - The executor to run the function in.

Returns:

A new accumulator that has recovered from errors.

through

public abstract <D> Accumulator<D,A> through(akka.stream.javadsl.Flow<D,E,?> flow)

Pass the stream through the given flow before forwarding it to the accumulator.

Parameters:

flow - The flow to send the stream through first.

Returns:

A new accumulator with the given flow in its graph.

run

public abstract java.util.concurrent.CompletionStage<A> run(akka.stream.Materializer mat)

Run the accumulator with an empty source.

Parameters:

mat - The flow materializer.

Returns:

A future that will be redeemed when the accumulator is done.

run

public abstract java.util.concurrent.CompletionStage<A> run(akka.stream.javadsl.Source<E,?> source,
                                                            akka.stream.Materializer mat)

Run the accumulator with the given source.

Parameters:

source - The source to feed into the accumulator.

mat - The flow materializer.

Returns:

A future that will be redeemed when the accumulator is done.

toSink

public abstract akka.stream.javadsl.Sink<E,java.util.concurrent.CompletionStage<A>> toSink()

Convert this accumulator to a sink.

Returns:

The sink.

asScala

public abstract play.api.libs.streams.Accumulator<E,A> asScala()

Convert this accumulator to a Scala accumulator.

Returns:

The Scala Accumulator.

fromSink

public static <E,A> Accumulator<E,A> fromSink(akka.stream.javadsl.Sink<E,java.util.concurrent.CompletionStage<A>> sink)

Create an accumulator from an Akka streams sink.

Parameters:

sink - The sink.

Returns:

An accumulator created from the sink.

source

public static <E> Accumulator<E,akka.stream.javadsl.Source<E,?>> source()

Create an accumulator that forwards the stream fed into it to the source it produces. This is useful for when you want to send the consumed stream to another API that takes a Source as input. Extreme care must be taken when using this accumulator - the source *must always* be materialized and consumed. If it isn't, this could lead to resource leaks and deadlocks upstream.

Returns:

An accumulator that forwards the stream to the produced source.

done

public static <E,A> Accumulator<E,A> done(A a)

Create a done accumulator with the given value.

Parameters:

a - The done value for the accumulator.

Returns:

The accumulator.

done

public static <E,A> Accumulator<E,A> done(java.util.concurrent.CompletionStage<A> a)

Create a done accumulator with the given future.

Parameters:

a - A future of the done value.

Returns:

The accumulator.