class AckedFlow[-In, +Out, +Mat] extends AckedFlowOpsMat[Out, Mat] with AckedGraph[AckedFlowShape[In, Out], Mat]

Linear Supertypes
AckedGraph[AckedFlowShape[In, Out], Mat], AckedFlowOpsMat[Out, Mat], AckedFlowOps[Out, Mat], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. AckedFlow
  2. AckedGraph
  3. AckedFlowOpsMat
  4. AckedFlowOps
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new AckedFlow(wrappedRepr: Flow[AckTup[In], AckTup[Out], Mat])

Type Members

  1. type AkkaShape = AckedFlowShape.AkkaShape
    Definition Classes
    AckedGraph
  2. type Repr[+O] = AckedFlow[In, O, Mat]
    Definition Classes
    AckedFlow → AckedFlowOpsMat → AckedFlowOps
  3. type ReprMat[+O, +M] = AckedFlow[In, O, M]
    Definition Classes
    AckedFlow → AckedFlowOpsMat
  4. type Shape = AckedFlowShape[In, Out]
    Definition Classes
    AckedGraph
  5. type UnwrappedRepr[+O] = Flow[In, O, Mat]
    Definition Classes
    AckedFlow → AckedFlowOpsMat → AckedFlowOps
  6. type UnwrappedReprMat[+O, +M] = Flow[In, O, M]
    Definition Classes
    AckedFlow → AckedFlowOpsMat
  7. type WrappedRepr[+O] = Flow[AckTup[In], AckTup[O], Mat]
    Definition Classes
    AckedFlow → AckedFlowOpsMat → AckedFlowOps
  8. type WrappedReprMat[+O, +M] = Flow[AckTup[In], AckTup[O], M]
    Definition Classes
    AckedFlow → AckedFlowOpsMat

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.Flow.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 addAttributes(attr: Attributes): Repr[Out]
    Definition Classes
    AckedFlow → AckedGraph
  7. val akkaGraph: Flow[AckTup[In], AckTup[Out], Mat]
    Definition Classes
    AckedFlow → AckedGraph
  8. def alsoTo(that: AckedGraph[AckedSinkShape[Out], _]): Repr[Out]
    Definition Classes
    AckedFlowOps
  9. def alsoToMat[Mat2, Mat3](that: AckedGraph[AckedSinkShape[Out], Mat2])(matF: (Mat, Mat2) ⇒ Mat3): ReprMat[Out, Mat3]
    Definition Classes
    AckedFlowOpsMat
  10. def andThen[U](next: WrappedRepr[U]): Repr[U]
    Attributes
    protected
    Definition Classes
    AckedFlow → AckedFlowOps
  11. def andThenMat[U, Mat2](next: WrappedReprMat[U, Mat2]): ReprMat[U, Mat2]
    Attributes
    protected
    Definition Classes
    AckedFlow → AckedFlowOpsMat
  12. def andThenSubFlow[U >: Out, Mat2 >: Mat](wrappedSubFlow: SubFlow[AckTup[U], Mat2, akka.stream.scaladsl.Flow.Repr, _]): AckedSubFlow[U, Mat2, Repr]
    Definition Classes
    AckedFlowOps
  13. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  14. 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
  15. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native() @HotSpotIntrinsicCandidate()
  16. implicit def collapse1to0[U, Mat2](next: akka.stream.scaladsl.Flow.Repr[AckTup[U]]): WrappedRepr[U]
    Definition Classes
    AckedFlowOps
    Annotations
    @inline()
  17. implicit def collapse2to0Mat[U, Mat2](next: (<refinement>.this)#ReprMat[AckTup[U], Mat2]): WrappedReprMat[U, Mat2]
    Attributes
    protected
    Definition Classes
    AckedFlowOpsMat
    Annotations
    @inline()
  18. 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
  19. def completionTimeout(timeout: FiniteDuration): Repr[Out]
    Definition Classes
    AckedFlowOps
  20. 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
  21. 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
  22. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  23. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  24. 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
  25. 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
  26. 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
  27. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  28. 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
  29. 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
  30. 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
  31. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  32. 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
  33. 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
  34. 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
  35. 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
  36. 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
  37. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  38. 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
  39. 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
  40. def map[T](f: (Out) ⇒ T): Repr[T]

    See FlowOps.map in akka-stream

    See FlowOps.map in akka-stream

    Definition Classes
    AckedFlowOps
  41. 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
  42. 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
  43. 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
  44. def mapMaterializedValue[Mat2](f: (Mat) ⇒ Mat2): ReprMat[Out, Mat2]

    Transform the materialized value of this AckedFlow, leaving all other properties as they were.

  45. 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
  46. def mergeMat[U >: Out, Mat2, Mat3](that: AckedGraph[AckedSourceShape[U], Mat2])(matF: (Mat, Mat2) ⇒ Mat3): ReprMat[U, Mat3]
    Definition Classes
    AckedFlowOpsMat
  47. def named(name: String): AckedGraph[AckedFlowShape[In, Out], Mat]
    Definition Classes
    AckedGraph
  48. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  49. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  50. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  51. lazy val shape: AckedFlowShape[In, Out]
    Definition Classes
    AckedFlow → AckedGraph
  52. def splitAfter[U >: Out](predicate: (Out) ⇒ Boolean): AckedSubFlow[Out, Mat, Repr]
    Definition Classes
    AckedFlowOps
  53. 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
  54. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  55. def take(n: Long): Repr[Out]

    See FlowOps.take in akka-stream

    See FlowOps.take in akka-stream

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

    See FlowOps.takeWhile in akka-stream

    See FlowOps.takeWhile in akka-stream

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

    See FlowOps.takeWithin in akka-stream

    See FlowOps.takeWithin in akka-stream

    Definition Classes
    AckedFlowOps
  58. def to[Mat2](sink: AckedSink[Out, Mat2]): AckedSink[In, Mat]
  59. def toMat[Mat2, Mat3](sink: AckedSink[Out, Mat2])(combine: (Mat, Mat2) ⇒ Mat3): AckedSink[In, Mat3]
  60. def toString(): String
    Definition Classes
    AnyRef → Any
  61. 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
  62. def via[T, Mat2](flow: AckedGraph[AckedFlowShape[Out, T], Mat2]): AckedFlow[In, T, Mat]

    See Flow.via in akka-stream

  63. def viaMat[T, Mat2, Mat3](flow: AckedGraph[AckedFlowShape[Out, T], Mat2])(combine: (Mat, Mat2) ⇒ Mat3): AckedFlow[In, T, Mat3]

    See Flow.viaMat in akka-stream

  64. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  65. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  66. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  67. def withAttributes(attr: Attributes): Repr[Out]
    Definition Classes
    AckedFlow → AckedGraph
  68. def wrapShape(akkaShape: akka.stream.scaladsl.Flow.Shape): Self
    Definition Classes
    AckedGraph
  69. val wrappedRepr: Flow[AckTup[In], AckTup[Out], Mat]
    Definition Classes
    AckedFlow → AckedFlowOps
  70. 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
  71. def zipMat[U, Mat2, Mat3](that: AckedGraph[AckedSourceShape[U], Mat2])(matF: (Mat, Mat2) ⇒ Mat3): ReprMat[(Out, U), Mat3]
    Definition Classes
    AckedFlowOpsMat
  72. 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
  73. def zipWithMat[Out2, Out3, Mat2, Mat3](that: AckedGraph[AckedSourceShape[Out2], Mat2])(combine: (Out, Out2) ⇒ Out3)(matF: (Mat, Mat2) ⇒ Mat3): ReprMat[Out3, Mat3]
    Definition Classes
    AckedFlowOpsMat

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 AckedGraph[AckedFlowShape[In, Out], Mat]

Inherited from AckedFlowOpsMat[Out, Mat]

Inherited from AckedFlowOps[Out, Mat]

Inherited from AnyRef

Inherited from Any

Ungrouped