Accumulator (Play 2.8.7)

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

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
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>`	`flatten(java.util.concurrent.CompletionStage<Accumulator<E,A>> stage, akka.stream.Materializer materializer)` Flatten a completion stage of an accumulator to an accumulator.
`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(E element, akka.stream.Materializer mat)` Run the accumulator with a single element.
`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.
`static <E,A> Accumulator<E,A>`	`strict(java.util.function.Function<java.util.Optional<E>,java.util.concurrent.CompletionStage<A>> strictHandler, akka.stream.javadsl.Sink<E,java.util.concurrent.CompletionStage<A>> toSink)` Create a done accumulator with the given future.
`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.
    
    Type Parameters:
    
    B - the mapped value type
    
    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.
    
    Type Parameters:
    
    B - the mapped value type
    
    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.
    
    Type Parameters:
    
    D - the "In" type for the flow parameter.
    
    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.
  - run
```
public abstract java.util.concurrent.CompletionStage<A> run(E element,
                                                            akka.stream.Materializer mat)
```
    Run the accumulator with a single element.
    
    Parameters:
    
    element - The element to feed into the accumulator.
    
    mat - The flow materilaizer.
    
    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.
    
    Type Parameters:
    
    E - the "in" type of the sink parameter.
    
    A - the materialized result of the accumulator.
    
    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.
    
    Type Parameters:
    
    E - the "in" type of the parameter.
    
    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.
    
    Type Parameters:
    
    E - the "in" type of the parameter.
    
    A - the materialized result of the accumulator.
    
    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.
    
    Type Parameters:
    
    E - the "in" type of the parameter.
    
    A - the materialized result of the accumulator.
    
    Parameters:
    
    a - A future of the done value.
    
    Returns:
    
    The accumulator.
  - strict
```
public static <E,A> Accumulator<E,A> strict(java.util.function.Function<java.util.Optional<E>,java.util.concurrent.CompletionStage<A>> strictHandler,
                                            akka.stream.javadsl.Sink<E,java.util.concurrent.CompletionStage<A>> toSink)
```
    Create a done accumulator with the given future.
    
    Type Parameters:
    
    E - the "in" type of the parameter.
    
    A - the materialized result of the accumulator.
    
    Parameters:
    
    strictHandler - the handler to handle the stream if it can be expressed as a single element.
    
    toSink - The sink representation of this accumulator, in case the stream can't be expressed as a single element.
    
    Returns:
    
    The accumulator.
  - flatten
```
public static <E,A> Accumulator<E,A> flatten(java.util.concurrent.CompletionStage<Accumulator<E,A>> stage,
                                             akka.stream.Materializer materializer)
```
    Flatten a completion stage of an accumulator to an accumulator.
    
    Type Parameters:
    
    E - the "in" type of the parameter.
    
    A - the materialized result of the accumulator.
    
    Parameters:
    
    stage - the CompletionStage (asynchronous) accumulator
    
    materializer - the stream materializer
    
    Returns:
    
    The accumulator using the given completion stage

Class Accumulator<E,A>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

map

mapFuture

recover

recoverWith

through

run

run

run

toSink

asScala

fromSink

source

done

done

strict

flatten