AckedFlowOps

Instance Constructors

new AckedFlowOps()

Type Members

abstract type Repr[+O, +M] <: AckedFlowOps[O, M]
abstract type UnwrappedRepr[+O, +M] <: FlowOps[O, M]
abstract type WrappedRepr[+O, +M] <: FlowOps[AckTup[O], M]

Abstract Value Members

abstract def andThen[U, Mat2](next: WrappedRepr[U, Mat2]): Repr[U, Mat2]

Attributes
protected
abstract val wrappedRepr: WrappedRepr[Out, Mat]

Attributes
protected

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def acked: WrappedRepr.Repr[Out, Mat]

Yields an Unwrapped Repr with only the data; after this point, message are acked.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def buffer(size: Int, failOnOverflow: Boolean = false): Repr[Out, Mat]

See FlowOps.buffer in akka-stream
See FlowOps.buffer in akka-stream
Does not accept an OverflowStrategy because only backpressure and fail are supported.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit def collapse1to0[U, Mat2 >: Mat](next: WrappedRepr.Repr[AckTup[U], Mat2]): WrappedRepr[U, Mat2]
def collect[T](pf: PartialFunction[Out, T]): Repr[T, Mat]

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.
def conflate[S](seed: (Out) ⇒ S)(aggregate: (S, Out) ⇒ S): Repr[S, Mat]

See FlowOps.conflate in akka-stream
See FlowOps.conflate in akka-stream
Conflated items are grouped together into a single message, the acknowledgement of which acknowledges every message that went into the group.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def filter(predicate: (Out) ⇒ Boolean): Repr[Out, Mat]

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.filter in akka-stream
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupBy[K, U >: Out](f: (Out) ⇒ K): WrappedRepr.Repr[(K, AckedSource[U, Unit]), Mat]

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
def grouped(n: Int): Repr[Seq[Out], Mat]

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).
def groupedWithin(n: Int, d: FiniteDuration): Repr[Seq[Out], Mat]

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).
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

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

See FlowOps.log in akka-stream
def map[T](f: (Out) ⇒ T): Repr[T, Mat]

See FlowOps.map in akka-stream
def mapAsync[T](parallelism: Int)(f: (Out) ⇒ Future[T]): Repr[T, Mat]

See FlowOps.mapAsync in akka-stream
def mapAsyncUnordered[T](parallelism: Int)(f: (Out) ⇒ Future[T]): Repr[T, Mat]

See FlowOps.mapAsyncUnordered in akka-stream
def mapConcat[T](f: (Out) ⇒ Iterable[T]): Repr[T, Mat]

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.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(n: Long): Repr[Out, Mat]

See FlowOps.take in akka-stream
def takeWhile(predicate: (Out) ⇒ Boolean): Repr[Out, Mat]

See FlowOps.takeWhile in akka-stream
def takeWithin(d: FiniteDuration): Repr[Out, Mat]

See FlowOps.takeWithin in akka-stream
def toString(): String

Definition Classes
AnyRef → Any
def unsafe: WrappedRepr[Out, Mat]

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.
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package acked

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

Instance Constructors

new AckedFlowOps()

Type Members

abstract type Repr[+O, +M] <: AckedFlowOps[O, M]

abstract type UnwrappedRepr[+O, +M] <: FlowOps[O, M]

abstract type WrappedRepr[+O, +M] <: FlowOps[AckTup[O], M]

Abstract Value Members

abstract def andThen[U, Mat2](next: WrappedRepr[U, Mat2]): Repr[U, Mat2]

abstract val wrappedRepr: WrappedRepr[Out, Mat]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def acked: WrappedRepr.Repr[Out, Mat]

final def asInstanceOf[T0]: T0

def buffer(size: Int, failOnOverflow: Boolean = false): Repr[Out, Mat]

def clone(): AnyRef

implicit def collapse1to0[U, Mat2 >: Mat](next: WrappedRepr.Repr[AckTup[U], Mat2]): WrappedRepr[U, Mat2]

def collect[T](pf: PartialFunction[Out, T]): Repr[T, Mat]

def conflate[S](seed: (Out) ⇒ S)(aggregate: (S, Out) ⇒ S): Repr[S, Mat]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(predicate: (Out) ⇒ Boolean): Repr[Out, Mat]

def finalize(): Unit

final def getClass(): Class[_]

def groupBy[K, U >: Out](f: (Out) ⇒ K): WrappedRepr.Repr[(K, AckedSource[U, Unit]), Mat]

def grouped(n: Int): Repr[Seq[Out], Mat]

def groupedWithin(n: Int, d: FiniteDuration): Repr[Seq[Out], Mat]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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

def map[T](f: (Out) ⇒ T): Repr[T, Mat]

def mapAsync[T](parallelism: Int)(f: (Out) ⇒ Future[T]): Repr[T, Mat]

def mapAsyncUnordered[T](parallelism: Int)(f: (Out) ⇒ Future[T]): Repr[T, Mat]

def mapConcat[T](f: (Out) ⇒ Iterable[T]): Repr[T, Mat]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def take(n: Long): Repr[Out, Mat]

def takeWhile(predicate: (Out) ⇒ Boolean): Repr[Out, Mat]

def takeWithin(d: FiniteDuration): Repr[Out, Mat]

def toString(): String

def unsafe: WrappedRepr[Out, Mat]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped