object Accumulator

Source
Accumulator.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Accumulator
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. def apply[E, A](sink: Sink[E, Future[A]]): Accumulator[E, A]

    Create a new accumulator from the given Sink.

  2. def done[A](a: Future[A]): Accumulator[Any, A]

    Create a done accumulator.

    Create a done accumulator.

    The underlying sink will cancel as soon as its onSubscribe method is called, and the materialized value will be the passed in future.

  3. def done[A](a: A): Accumulator[Any, A]

    Create a done accumulator.

    Create a done accumulator.

    The underlying sink will cancel as soon as its onSubscribe method is called, and the materialized value will be an immediately available future of a.

  4. def flatten[E, A](future: Future[Accumulator[E, A]])(implicit materializer: Materializer): Accumulator[E, A]

    Flatten a future of an accumulator to an accumulator.

  5. def source[E]: Accumulator[E, Source[E, _]]

    Create an accumulator that forwards the stream fed into it to the source it produces.

    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.

  6. def strict[E, A](strictHandler: (Option[E]) => Future[A], toSink: Sink[E, Future[A]]): Accumulator[E, A]

    Create an accumulator that is capable of handling the stream as a single, possibly empty, element, with a sink provided as a fallback if the stream can't be expressed as a single element.

    Create an accumulator that is capable of handling the stream as a single, possibly empty, element, with a sink provided as a fallback if the stream can't be expressed as a single element.

    This is intended to be able to be used to avoid a stream materialization for strict entities.