Packages

class Impl[+Out, +Mat, +F[+_], +G[+_]] extends AckedFlowOps[Out, Mat] with AckedSubFlow[Out, Mat, F]

Linear Supertypes
AckedSubFlow[Out, Mat, F], AckedFlowOps[Out, Mat], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Impl
  2. AckedSubFlow
  3. AckedFlowOps
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Impl(wrappedRepr: SubFlow[AckTup[Out], Mat, G, _], rewrap: Converter[G, F])

Type Members

  1. type Repr[+T] = AckedSubFlow[T, Mat, F]
    Definition Classes
    AckedSubFlow → AckedFlowOps
  2. abstract type UnwrappedRepr[+O] <: SubFlow[O, Mat, G, _]
    Definition Classes
    Impl → AckedFlowOps
  3. type WrappedRepr[+O] = SubFlow[AckTup[O], Mat, G, _]
    Definition Classes
    Impl → AckedFlowOps

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. def ++[U >: Out, Mat2](that: AckedGraph[AckedSourceShape[U], Mat2]): Repr[U]

    Concatenates this Flow with the given Source so the first element emitted by that source is emitted after the last element of this flow.

    Concatenates this Flow with the given Source so the first element emitted by that source is emitted after the last element of this flow.

    See FlowOps.++ in akka-stream

    Definition Classes
    AckedFlowOps
  4. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. def acked: akka.stream.scaladsl.SubFlow.Repr[Out]

    Yields an Unwrapped Repr with only the data; after this point, message are acked.

    Yields an Unwrapped Repr with only the data; after this point, message are acked.

    Definition Classes
    AckedFlowOps
  6. def alsoTo(that: AckedGraph[AckedSinkShape[Out], _]): Repr[Out]
    Definition Classes
    AckedFlowOps
  7. def andThen[U](next: WrappedRepr[U]): Repr[U]
    Attributes
    protected
    Definition Classes
    Impl → AckedFlowOps
  8. def andThenSubFlow[U >: Out, Mat2 >: Mat](wrappedSubFlow: SubFlow[AckTup[U], Mat2, akka.stream.scaladsl.SubFlow.Repr, _]): AckedSubFlow[U, Mat2, Repr]
    Definition Classes
    AckedFlowOps
  9. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  10. def buffer(size: Int, failOnOverflow: Boolean = false): Repr[Out]

    See FlowOps.buffer in akka-stream

    See FlowOps.buffer in akka-stream

    Does not accept an OverflowStrategy because only backpressure and fail are supported.

    Definition Classes
    AckedFlowOps
  11. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native() @HotSpotIntrinsicCandidate()
  12. implicit def collapse1to0[U, Mat2](next: akka.stream.scaladsl.SubFlow.Repr[AckTup[U]]): WrappedRepr[U]
    Definition Classes
    AckedFlowOps
    Annotations
    @inline()
  13. def collect[T](pf: PartialFunction[Out, T]): Repr[T]

    See FlowOps.collect in akka-stream

    See FlowOps.collect in akka-stream

    A map and a filter. Elements for which the provided PartialFunction is not defined are acked.

    Definition Classes
    AckedFlowOps
  14. def completionTimeout(timeout: FiniteDuration): Repr[Out]
    Definition Classes
    AckedFlowOps
  15. def concat[U >: Out, Mat2](that: AckedGraph[AckedSourceShape[U], Mat2]): Repr[U]

    Concatenates this Flow with the given Source so the first element emitted by that source is emitted after the last element of this flow.

    Concatenates this Flow with the given Source so the first element emitted by that source is emitted after the last element of this flow.

    See FlowOps.concat in akka-stream

    Definition Classes
    AckedFlowOps
  16. def concatSubstreams: F[Out]

    Flatten the sub-flows back into the super-flow by concatenating them.

    Flatten the sub-flows back into the super-flow by concatenating them. This is usually a bad idea when combined with groupBy since it can easily lead to deadlock—the concatenation does not consume from the second substream until the first has finished and the groupBy stage will get back-pressure from the second stream.

    This is identical in effect to mergeSubstreamsWithParallelism(1).

    Definition Classes
    AckedSubFlow
  17. def conflateWithSeed[S](seed: (Out) ⇒ S)(aggregate: (S, Out) ⇒ S): Repr[S]

    See FlowOps.conflateWithSeed in akka-stream

    See FlowOps.conflateWithSeed in akka-stream

    Conflated items are grouped together into a single message, the acknowledgement of which acknowledges every message that went into the group.

    Definition Classes
    AckedFlowOps
  18. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  19. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  20. def filter(predicate: (Out) ⇒ Boolean): Repr[Out]

    Filters elements from the stream for which the predicate returns false.

    Filters elements from the stream for which the predicate returns false. Filtered items are acked.

    See FlowOps.filter in akka-stream

    Definition Classes
    AckedFlowOps
  21. def filterNot(predicate: (Out) ⇒ Boolean): Repr[Out]

    Filters elements from the stream for which the predicate returns true.

    Filters elements from the stream for which the predicate returns true. Filtered items are acked.

    See FlowOps.filterNot in akka-stream

    Definition Classes
    AckedFlowOps
  22. def fold[T](zero: T)(f: (T, Out) ⇒ T): Repr[T]

    Similar to scan but only emits its result when the upstream completes, after which it also completes.

    Similar to scan but only emits its result when the upstream completes, after which it also completes. Applies the given function towards its current and next value, yielding the next current value.

    If the function f throws an exception and the supervision decision is akka.stream.Supervision.Restart current value starts at zero again the stream will continue.

    Emits when upstream completes

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Definition Classes
    AckedFlowOps
  23. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  24. def groupBy[K, U >: Out](maxSubstreams: Int, f: (Out) ⇒ K): AckedSubFlow[Out, Mat, Repr]

    Yields a non-acked flow/source of AckedSource, keyed by the return value of the provided function.

    Yields a non-acked flow/source of AckedSource, keyed by the return value of the provided function.

    See FlowOps.groupBy in akka-stream

    Definition Classes
    AckedFlowOps
  25. def grouped(n: Int): Repr[Seq[Out]]

    See FlowOps.grouped in akka-stream

    See FlowOps.grouped in akka-stream

    Downstream acknowledgement applies to the resulting group (IE: if it yields a group of 100, then downstream you can only either ack or nack the entire group).

    Definition Classes
    AckedFlowOps
  26. def groupedWithin(n: Int, d: FiniteDuration): Repr[Seq[Out]]

    See FlowOps.groupedWithin in akka-stream

    See FlowOps.groupedWithin in akka-stream

    Downstream acknowledgement applies to the resulting group (IE: if it yields a group of 100, then downstream you can only either ack or nack the entire group).

    Definition Classes
    AckedFlowOps
  27. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  28. def idleTimeout(timeout: FiniteDuration): Repr[Out]

    If the time between two processed elements exceed the provided timeout, the stream is failed with a scala.concurrent.TimeoutException.

    If the time between two processed elements exceed the provided timeout, the stream is failed with a scala.concurrent.TimeoutException.

    Definition Classes
    AckedFlowOps
  29. def initialDelay(delay: FiniteDuration): Repr[Out]

    Delays the initial element by the specified duration.

    Delays the initial element by the specified duration.

    Definition Classes
    AckedFlowOps
  30. def initialTimeout(timeout: FiniteDuration): Repr[Out]

    If the first element has not passed through this stage before the provided timeout, the stream is failed with a scala.concurrent.TimeoutException.

    If the first element has not passed through this stage before the provided timeout, the stream is failed with a scala.concurrent.TimeoutException.

    Definition Classes
    AckedFlowOps
  31. def intersperse[T >: Out](start: T, inject: T, end: T): Repr[T]

    Intersperses stream with provided element, similar to how scala.collection.immutable.List.mkString injects a separator between a List's elements.

    Intersperses stream with provided element, similar to how scala.collection.immutable.List.mkString injects a separator between a List's elements.

    Definition Classes
    AckedFlowOps
  32. def intersperse[T >: Out](inject: T): Repr[T]

    Intersperses stream with provided element, similar to how scala.collection.immutable.List.mkString injects a separator between a List's elements.

    Intersperses stream with provided element, similar to how scala.collection.immutable.List.mkString injects a separator between a List's elements.

    Definition Classes
    AckedFlowOps
  33. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  34. def keepAlive[U >: Out](maxIdle: FiniteDuration, injectedElem: () ⇒ U): Repr[U]

    Injects additional elements if the upstream does not emit for a configured amount of time.

    Injects additional elements if the upstream does not emit for a configured amount of time.

    Definition Classes
    AckedFlowOps
  35. def log(name: String, extract: (Out) ⇒ Any = identity)(implicit log: LoggingAdapter = null): Repr[Out]

    See FlowOps.log in akka-stream

    See FlowOps.log in akka-stream

    Definition Classes
    AckedFlowOps
  36. def map[T](f: (Out) ⇒ T): Repr[T]

    See FlowOps.map in akka-stream

    See FlowOps.map in akka-stream

    Definition Classes
    AckedFlowOps
  37. def mapAsync[T](parallelism: Int)(f: (Out) ⇒ Future[T]): Repr[T]

    See FlowOps.mapAsync in akka-stream

    See FlowOps.mapAsync in akka-stream

    Definition Classes
    AckedFlowOps
  38. def mapAsyncUnordered[T](parallelism: Int)(f: (Out) ⇒ Future[T]): Repr[T]

    See FlowOps.mapAsyncUnordered in akka-stream

    See FlowOps.mapAsyncUnordered in akka-stream

    Definition Classes
    AckedFlowOps
  39. def mapConcat[T](f: (Out) ⇒ Iterable[T]): Repr[T]

    See FlowOps.mapConcat in akka-stream

    See FlowOps.mapConcat in akka-stream

    Splits a single element into 0 or more items.

    If 0 items, then signal completion of this element. Otherwise, signal completion of this element after all resulting elements are signaled for completion.

    Definition Classes
    AckedFlowOps
  40. def merge[U >: Out](that: AckedGraph[AckedSourceShape[U], _]): Repr[U]

    Merge the given Source to this Flow, taking elements as they arrive from input streams, picking randomly when several elements ready.

    Merge the given Source to this Flow, taking elements as they arrive from input streams, picking randomly when several elements ready.

    Emits when one of the inputs has an element available

    Backpressures when downstream backpressures

    Completes when all upstreams complete

    Cancels when downstream cancels

    Definition Classes
    AckedFlowOps
  41. def mergeSubstreams: F[Out]

    Flatten the sub-flows back into the super-flow by performing a merge without parallelism limit (i.e.

    Flatten the sub-flows back into the super-flow by performing a merge without parallelism limit (i.e. having an unbounded number of sub-flows active concurrently).

    This is identical in effect to mergeSubstreamsWithParallelism(Integer.MAX_VALUE).

    Definition Classes
    AckedSubFlow
  42. def mergeSubstreamsWithParallelism(parallelism: Int): F[Out]

    Flatten the sub-flows back into the super-flow by performing a merge with the given parallelism limit.

    Flatten the sub-flows back into the super-flow by performing a merge with the given parallelism limit. This means that only up to parallelism substreams will be executed at any given time. Substreams that are not yet executed are also not materialized, meaning that back-pressure will be exerted at the operator that creates the substreams when the parallelism limit is reached.

    Definition Classes
    Impl → AckedSubFlow
  43. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  44. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  45. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  46. def splitAfter[U >: Out](predicate: (Out) ⇒ Boolean): AckedSubFlow[Out, Mat, Repr]
    Definition Classes
    AckedFlowOps
  47. def splitWhen[U >: Out](predicate: (Out) ⇒ Boolean): AckedSubFlow[Out, Mat, Repr]

    This operation applies the given predicate to all incoming elements and emits them to a stream of output streams, always beginning a new one with the current element if the given predicate returns true for it.

    This operation applies the given predicate to all incoming elements and emits them to a stream of output streams, always beginning a new one with the current element if the given predicate returns true for it. This means that for the following series of predicate values, three substreams will be produced with lengths 1, 2, and 3:

    false,             // element goes into first substream
true, false,       // elements go into second substream
true, false, false // elements go into third substream

    In case the *first* element of the stream matches the predicate, the first substream emitted by splitWhen will start from that element. For example:

    true, false, false // first substream starts from the split-by element
true, false        // subsequent substreams operate the same way

    If the split predicate p throws an exception and the supervision decision is akka.stream.Supervision.Stop the stream and substreams will be completed with failure.

    If the split predicate p throws an exception and the supervision decision is akka.stream.Supervision.Resume or akka.stream.Supervision.Restart the element is dropped and the stream and substreams continue.

    Exceptions thrown in predicate will be propagated via the acknowledgement channel

    Emits when an element for which the provided predicate is true, opening and emitting a new substream for subsequent element

    Backpressures when there is an element pending for the next substream, but the previous is not fully consumed yet, or the substream backpressures

    Completes when upstream completes

    Cancels when downstream cancels and substreams cancel

    Definition Classes
    AckedFlowOps
  48. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  49. def take(n: Long): Repr[Out]

    See FlowOps.take in akka-stream

    See FlowOps.take in akka-stream

    Definition Classes
    AckedFlowOps
  50. def takeWhile(predicate: (Out) ⇒ Boolean): Repr[Out]

    See FlowOps.takeWhile in akka-stream

    See FlowOps.takeWhile in akka-stream

    Definition Classes
    AckedFlowOps
  51. def takeWithin(d: FiniteDuration): Repr[Out]

    See FlowOps.takeWithin in akka-stream

    See FlowOps.takeWithin in akka-stream

    Definition Classes
    AckedFlowOps
  52. def toString(): String
    Definition Classes
    AnyRef → Any
  53. def unsafe: WrappedRepr[Out]

    Yields an unacked Repr with the promise and the data.

    Yields an unacked Repr with the promise and the data. Note, this is inherently unsafe, as the method says. There is no timeout for the acknowledgement promises. Failing to complete the promises will cause a consumer with a non-infinite QoS to eventually stall.

    Definition Classes
    AckedFlowOps
  54. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  55. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  56. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  57. val wrappedRepr: SubFlow[AckTup[Out], Mat, G, _]
    Definition Classes
    Impl → AckedFlowOps
  58. def zip[U](that: AckedGraph[AckedSourceShape[U], _]): Repr[(Out, U)]

    Combine the elements of current flow and the given Source into a stream of tuples.

    Combine the elements of current flow and the given Source into a stream of tuples.

    Definition Classes
    AckedFlowOps
  59. def zipWith[Out2, Out3](that: AckedGraph[AckedSourceShape[Out2], _])(combine: (Out, Out2) ⇒ Out3): Repr[Out3]

    Put together the elements of current flow and the given Source into a stream of combined elements using a combiner function.

    Put together the elements of current flow and the given Source into a stream of combined elements using a combiner function.

    Definition Classes
    AckedFlowOps

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] ) @Deprecated @deprecated
    Deprecated

    (Since version ) see corresponding Javadoc for more information.

Inherited from AckedSubFlow[Out, Mat, F]

Inherited from AckedFlowOps[Out, Mat]

Inherited from AnyRef

Inherited from Any

Ungrouped