c

com.timcharper.acked

AckedFlowOps

abstract class AckedFlowOps[+Out, +Mat] extends AnyRef

Self Type
AckedFlowOps[Out, Mat]
Linear Supertypes
AnyRef, Any
Known Subclasses
AckedFlow, AckedFlowOpsMat, AckedSource, AckedSubFlow, Impl
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. AckedFlowOps
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new AckedFlowOps()

Type Members

  1. abstract type Repr[+O] <: AckedFlowOps[O, Mat]
  2. abstract type UnwrappedRepr[+O] <: FlowOps[O, Mat]
  3. abstract type WrappedRepr[+O] <: FlowOps[AckTup[O], Mat]

Abstract Value Members

  1. abstract def andThen[U](next: WrappedRepr[U]): Repr[U]
    Attributes
    protected
  2. abstract val wrappedRepr: WrappedRepr[Out]
    Attributes
    protected

Concrete 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

  4. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. def acked: WrappedRepr.Repr[Out]

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

  6. def alsoTo(that: AckedGraph[AckedSinkShape[Out], _]): Repr[Out]
  7. def andThenSubFlow[U >: Out, Mat2 >: Mat](wrappedSubFlow: SubFlow[AckTup[U], Mat2, WrappedRepr.Repr, _]): AckedSubFlow[U, Mat2, Repr]
  8. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  9. 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.

  10. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native() @HotSpotIntrinsicCandidate()
  11. implicit def collapse1to0[U, Mat2](next: WrappedRepr.Repr[AckTup[U]]): WrappedRepr[U]
    Annotations
    @inline()
  12. 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.

  13. def completionTimeout(timeout: FiniteDuration): Repr[Out]
  14. 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

  15. 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.

  16. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  17. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  18. 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

  19. 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

  20. 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

  21. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  22. 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

  23. 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).

  24. 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).

  25. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  26. 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.

  27. def initialDelay(delay: FiniteDuration): Repr[Out]

    Delays the initial element by the specified duration.

  28. 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.

  29. 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.

  30. 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.

  31. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  32. 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.

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

    See FlowOps.log in akka-stream

  34. def map[T](f: (Out) ⇒ T): Repr[T]

    See FlowOps.map in akka-stream

  35. def mapAsync[T](parallelism: Int)(f: (Out) ⇒ Future[T]): Repr[T]

    See FlowOps.mapAsync in akka-stream

  36. def mapAsyncUnordered[T](parallelism: Int)(f: (Out) ⇒ Future[T]): Repr[T]

    See FlowOps.mapAsyncUnordered in akka-stream

  37. 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.

  38. 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

  39. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  40. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  41. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  42. def splitAfter[U >: Out](predicate: (Out) ⇒ Boolean): AckedSubFlow[Out, Mat, Repr]
  43. 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

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

    See FlowOps.take in akka-stream

  46. def takeWhile(predicate: (Out) ⇒ Boolean): Repr[Out]

    See FlowOps.takeWhile in akka-stream

  47. def takeWithin(d: FiniteDuration): Repr[Out]

    See FlowOps.takeWithin in akka-stream

  48. def toString(): String
    Definition Classes
    AnyRef → Any
  49. 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.

  50. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  51. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  52. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  53. 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.

  54. 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.

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 AnyRef

Inherited from Any

Ungrouped