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.
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
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.
See FlowOps.buffer in akka-stream
See FlowOps.buffer in akka-stream
Does not accept an OverflowStrategy because only backpressure and fail are supported.
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.
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
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)
.
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.
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
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
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
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
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).
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).
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.
Delays the initial element by the specified duration.
Delays the initial element by the specified duration.
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.
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.
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.
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.
See FlowOps.log in akka-stream
See FlowOps.log in akka-stream
See FlowOps.map in akka-stream
See FlowOps.map in akka-stream
See FlowOps.mapAsync in akka-stream
See FlowOps.mapAsync in akka-stream
See FlowOps.mapAsyncUnordered in akka-stream
See FlowOps.mapAsyncUnordered in akka-stream
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.
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
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)
.
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
See FlowOps.take in akka-stream
See FlowOps.take in akka-stream
See FlowOps.takeWhile in akka-stream
See FlowOps.takeWhile in akka-stream
See FlowOps.takeWithin in akka-stream
See FlowOps.takeWithin in akka-stream
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.
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.
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.