Packages

  • package root
    Definition Classes
    root
  • package akka
    Definition Classes
    root
  • package stream
    Definition Classes
    akka
  • package impl

    The architecture of Akka Streams internally consists of several distinct layers:

    The architecture of Akka Streams internally consists of several distinct layers:

    * The DSLs like akka.stream.scaladsl.Flow, akka.stream.scaladsl.Source etc. are the user facing API for composing streams. These DSLs are a thin wrappers around the internal akka.stream.impl.TraversalBuilder builder classes. There are Java alternatives of these DSLs in javadsl which basically wrap their scala counterpart, delegating method calls. * The akka.stream.stage.GraphStage API is the user facing API for creating new stream operators. These classes are used by the akka.stream.impl.fusing.GraphInterpreter which executes islands (subgraphs) of these operators * The high level DSLs use the akka.stream.impl.TraversalBuilder classes to build instances of akka.stream.impl.Traversal which are the representation of a materializable stream description. These builders are immutable and safely shareable. Unlike the top-level DSLs, these are classic, i.e. elements are treated as Any. * The akka.stream.impl.Traversal is the immutable, efficient representation of a stream processing graph that can be materialized. The builders exists solely for the purpose of producing a traversal in the end. * The akka.stream.impl.PhasedFusingActorMaterializer is the class that is responsible for traversing and interpreting a akka.stream.impl.Traversal. It delegates the actual task of creating executable entities and Publishers/Producers to akka.stream.impl.PhaseIslands which are plugins that understand atomic operators in the graph and able to turn them into executable entities. * The akka.stream.impl.fusing.GraphInterpreter and its actor backed wrapper akka.stream.impl.fusing.ActorGraphInterpreter are used to execute synchronous islands (subgraphs) of akka.stream.stage.GraphStages.

    For the execution layer, refer to akka.stream.impl.fusing.GraphInterpreter.

    Design goals

    The central piece for both the DSLs and materialization is the akka.stream.impl.Traversal. This is the representation of an Akka Stream, basically a akka.stream.scaladsl.RunnableGraph. The design goals for akka.stream.impl.Traversal are:

    * Be able to materialize a graph in one pass over the traversal * Unify materialization and fusing. The materializer should be able to construct all the necessary data structures for the interpreters and for connecting them in one go. * Avoid allocations as much as possible. * Biased implementation for the 90% case. Common cases should be as fast as possible: * wiring linear chains should be very fast. * assume that most graphs are mostly linear, with only a few generalized graph constructs thrown in. * materialization should not pay the price of island tracking if there is only a single island * assume that the number of islands is low in general * avoid "copiedModule" i.e. wrappers that exist solely for the purpose of establishing new port identities for operators that are used multiple times in the same graph. * Avoid hashmaps and prefer direct array lookup wherever possible

    Semantically, a traversal is a list of commands that the materializer must execute to turn the description to a running stream. In fact, the traversal is nothing more than an immutable list, that is expressed as a tree. A tree is used to make immutable appends fast (immutable lists only have prepend as O(1) operation, append is O(N)). The materializer "recovers" the original sequence by using a local, mutable stack to properly traverse the tree structure. This is way cheaper than to immutably append to the traversal at each addition.

    The "tree-ness" is expressed by explicit akka.stream.impl.Concat nodes that express that two traversals need to be traversed in a certain sequence, stashing away the second on a local stack until the first is fully traversed.

    While traversing the traversal (basically following Concat nodes), the materializer will visit the following command types:

    * akka.stream.impl.MaterializeAtomic: An atomic module needs to be materialized. This node also contains wiring information which we discuss later. * Materialized value computation. This is a stack based "sublanguage" to compute the final materialized value on a stack, maintained by the materializer * akka.stream.impl.PushNotUsed push a NotUsed value on the stack * akka.stream.impl.Pop pop the top of the stack and throw away * akka.stream.impl.Transform take the top of the stack, transform it with the provided function and put the result back on the top of the stack * akka.stream.impl.Compose take the top two values of the stack, invoke the provided function with these values as arguments, then put the calculated value on the top of the stack * Materialized values of atomic operators when visiting a akka.stream.impl.MaterializeAtomic must be pushed to the stack automatically. There are no explicit PUSH commands for this * Attributes calculation. These also are a stack language, although much simpler than the materialized value commands. For any materialized operator, the top of the attributes stack should be provided as the current effective attributes. * akka.stream.impl.PushAttributes combines the attributes on the top of the stack with the given ones and puts the result on the attributes stack * akka.stream.impl.PopAttributes removes the top of the attributes stack. * Island tracking. Islands serve two purposes. First, they allow a large graph to be cut into parts that execute concurrently with each other, using asynchronous message passing between themselves. Second, they are an extension point where "plugins" (akka.stream.impl.PhaseIsland) can be used to specially handle subgraphs. Islands can be nested in each other. This makes "holes" in the parent island. Islands also need a stack as exiting a "hole" means returning to the parent, enclosing island and continuing where left. * akka.stream.impl.EnterIsland instructs the materializer that the following commands will belong to the materialization of a new island (a subgraph). The akka.stream.impl.IslandTag signals to the materializer which akka.stream.impl.PhaseIsland should be used to turn operators of this island into executable entities. * akka.stream.impl.ExitIsland instructs the materializer that the current island is done and the parent island is now the active one again.

    Please note that the stack based materialized value computation eliminates the issues present in the older materializer which expressed these computations as an AST. We had to use optimizations for this tree so that long Keep.left chains don't explode the stack visiting a large AST. The stack based language sidesteps this issue completely as the number of these commands don't increase the stack space required to execute them, unless the computation itself requires it (which is not the case in any sane stream combination).

    Graph model, offsets, slots

    As a mental model, the wiring part of the Traversal (i.e. excluding the stack based sub-commands tracking materialized values, attributes, islands, i.e. things that don't contribute to the wiring structure of the graph) translates everything to a single, global, contiguous Array. Every input and output port of each operator is mapped to exactly one slot of this "mental array". Input and output ports that are considered wired together simply map to the same slot. (In practice, these slots might not be mapped to an actual global array, but multiple local arrays using some translation logic, but we will explain this later)

    Input ports are mapped simply to contiguous numbers in the order they are visited. Take for example a simple traversal:

    Operator1[in1, in2, out] - Operator2[out] - Operator3[in]

    This results in the following slot assignments:

    * Operator1.in1 -> 0 * Operator1.in2 -> 1 * Operator3.in -> 2

    The materializer simply visits Stage1, Stage2, Stage3 in order, visiting the input ports of each operator in order. It then simply assigns numbers from a counter that is incremented after visiting an input port. (Please note that all akka.stream.impl.StreamLayout.AtomicModules maintain a stable order of their ports, so this global ordering is well defined)

    Before explaining how output wiring works, it is important to settle some terminology. When we talk about ports we refer to their location in the "mental array" as slots. However, there are other entities that needs to reference various positions in this "mental array", but in these cases we use the term _offset_ to signify that these are only used for bookkeeping, they have no "place" in the "array" themselves. In particular:

    * offset of a module: The offset of an akka.stream.impl.StreamLayout.AtomicModule is defined as the value of the input port counter when visiting the akka.stream.impl.MaterializeAtomic node to materialize that module. In other words, the offset of a module is the slot of its first input port (if there is any). Since modules might not have any input ports it can be that different modules share the same offset, simply because the the first one visited does not increase the input port counter. * offset of segments, islands: Defined similarly to module. The offset of an island or a segment is simply the value of the input port counter (or the first unallocated slot).

    For example:

    Module1[in1 = 0, in2 = 1] - Module2[out] - Module3[in = 2]

    The offset of Module1 is 0, while Module2 and Module3 share the same offset of 2. Note that only input ports (slots) contribute to the offset of a module in a traversal.

    Output ports are wired relative to the offset of the module they are contained in. When the materializer visits a akka.stream.impl.MaterializeAtomic node, it contains an Array that maps ports to a relative offset. To calculate the slot that is assigned to an output port the following formula is used:

    slot = offsetOfModule + outToSlots(out.id)

    Where outToSlots is the array contained in the akka.stream.impl.MaterializeAtomic node.

    Relative addressing

    The power of this structure comes from the fact that slots are assigned in a relative manner:

    * input ports are assigned in sequence so the slots assigned to the input ports of a subgraph depend on the subgraph's position in the traversal * output ports are assigned relative to the offset of their owner module, which is in turn relative to its first (potential) input port (which is relative, too, because of the previous point)

    This setup allows combining subgraphs without touching their internal wirings as all their internal wirings will properly resolve due to everything being relative:

    +---------------+ +----+ | | | | |---------Graph1---------|--- .... ---|----Graph2----|

    It is important to note that due to reusability, an Akka Stream graph may contain the same atomic or composite multiple times in the same graph. Since these must be distinguished from each other somehow, they need port mapping (i.e. a new set of ports) to ensure that the ports of one graph are distinguishable from another. Because how the traversal relative addressing works, these are _temporary_ though, once all internal wirings are ready, these mappings can be effectively dropped as the global slot assignments uniquely identify what is wired to what. For example since Graph1 is visited before Graph2 all of the slots or offsets it uses are different from Graph2 leaving no room for misinterpretation.

    Port mapping

    Port mapping is the way how the DSL can distinguish between multiple instances of the same graph included multiple times. For example in the Graph DSL:

    val merge1 = builder.add(Merge) val merge2 = builder.add(Merge)

    the port merge1.out must be different from merge2.out.

    For efficiency reasons, the linear and graph DSLs use different akka.stream.impl.TraversalBuilder types to build the akka.stream.impl.Traversal (we will discuss these next). One of the differences between the two builders are their approach to port mapping.

    The simpler case is the akka.stream.impl.LinearTraversalBuilder. This builder only allows building linear chains of operators, hence, it can only have at most one OutPort and InPort unwired. Since there is no possible ambiguity between these two port types, there is no need for port mapping for these. Conversely, for those internal ports that are already wired, there is no need for port mapping as their relative wiring is not ambiguous (see previous section). As a result, the akka.stream.impl.LinearTraversalBuilder does not use any port mapping.

    The generic graph builder class akka.stream.impl.CompositeTraversalBuilder needs port mapping as it allows adding any kind of builders in any order. When adding a module (encoded as another akka.stream.impl.TraversalBuilder) there are two entities in play:

    * The module (builder) to be added. This builder has a few ports unwired which are usually packaged in a Shape which is stored alongside with the builder in the Graph of the DSL. When invoking methods on this builder these set of ports must be used. * The module that we are growing. This module needs a new set of ports to be used as it might add this module multiple times and needs to disambiguate these ports.

    Adding to the akka.stream.impl.CompositeTraversalBuilder involves the following steps (pseudocode):

    val newShape = shape.deepCopy() // Copy the shape of the module we want to add val newBuilder = builder.add(submodule, newShape) // Add the module, and register it with the new shape newBuilder.wire(newShape.in, ...) // Use the new ports to wire

    What happens in the background is that Shape.deepCopy creates copies of the ports, and fills their mappedTo field to point to their original port counterpart. Whenever we call wire in the outer module, it delegates calls to the submodule, but using the original port (as the submodule builder has no knowledge of the external mapping):

    submodule.assign(port.mappedTo, ...) // enclosing module delegating to submodule, translating ports back

    Visualizing this relationship:

    +----------------------------------+ | in', in" ---------+ | in' and in" both resolve to in | | .mappedTo v .mappedTo | but they will be used on _different_ builders | +-------------+ +-------------+ | | | in | | in | | (delegation happens recursively in AddedModule) | | AddedModule | | AddedModule | |

    It is worth to note that the submodule might also continue this map-and-delegate chain to further submodules until a builder is reached that can directly perform the operation. In other words, the depth of nesting is equal to the length of mappedTo chaining.

    IMPORTANT: When wiring in the enclosing module the new ports/shape MUST be used, using the original ports/shape will lead to incorrect state.

    TraversalBuilders

    In order to understand why builders are needed, consider wiring two ports together. Actually, we don't need to wire input ports anywhere. Their slot is implicitly assigned by their position in the traversal, there is no additional state we need to track. On the other hand, we cannot build a akka.stream.impl.MaterializeAtomic node until the mapping array outToSlots is fully calculated. In other words, in reality, we don't wire input ports anywhere, we only assign output ports to slots. The builders exist mainly to keep track all the necessary information to be able to assign output ports, build the outToSlots array and finally the akka.stream.impl.MaterializeAtomic node. The consequence of this that a akka.stream.impl.Traversal can be constructed as soon as all output ports are wired ("unwired" inputs don't matter).

    There is a specific builder that is used for the cases where all outputs have been wired: akka.stream.impl.CompletedTraversalBuilder. This builder type simply contains the completed traversal plus some additional data. The reason why this builder type exists is to keep auxiliary data structures required for output port mapping only while they are needed, and shed them as soon as they are not needed anymore. Since builders may recursively contain other builders, as soon as internals are completed those contained builders transition to completed state and drop all additional data structures. This is very GC friendly as many intermediate graphs exist only in a method call, and hence most of the additional data structures are dropped before method return and can be efficiently collected by the GC.

    The most generic builder is akka.stream.impl.CompositeTraversalBuilder. There are two main considerations this builder needs to consider:

    * Enclosed modules (builders) must have a stable position in the final traversal for relative addressing to work. Since module offsets are calculated by traversal position, and outputs are wired relative to module offset, this is critical. * Enclosed builders might not be complete yet (i.e. have unwired outputs) and hence they cannot immediately give a Traversal.

    The composite builder keeps a temporary list of traversal steps (in reverse order because of immutable lists) it needs to create once it is completed (all outputs wired). These steps refer to the traversal of submodules as a akka.stream.impl.BuilderKey which is just a placeholder where the traversal of the submodule will be stitched in. This akka.stream.impl.BuilderKey is also a key to a map which contains the evolving builder. The importance of this "preimage" traversal is that it keeps position of submodules stable, making relative addressing possible.

    Once the composite is completed, it takes these steps (now reversing it back to normal), and builds the traversal using the submodule traversals referred to by akka.stream.impl.BuilderKey. Note that at this point all the submodules are akka.stream.impl.CompletedTraversalBuilders because there are no unwired outputs and hence the Traversal can be assembled. As the builder evolves over time, more and more of its akka.stream.impl.BuilderKeys will refer to akka.stream.impl.CompletedTraversalBuilders, shedding much of the temporary data structures.

    Refer to akka.stream.impl.CompositeTraversalBuilder for more details.

    The akka.stream.impl.LinearTraversalBuilder is a much simpler beast. For efficiency, it tries to work as much as possible directly on the akka.stream.impl.Traversal avoiding auxiliary structures. The two main considerations for this builder are:

    * akka.stream.scaladsl.Source and akka.stream.scaladsl.Flow contain an unwired output port. Yet, we would like to build the traversal directly as much as possible, even though the builder is not yet completed * akka.stream.impl.CompositeTraversalBuilders might be included in a linear chain. These cannot provide a traversal before they are fully completed.

    The linear builder, although it is one class, comes in basically two flavors:

    * Purely linear builder: this contains only other linear builders, or all the composites that it includes have been fully wired before and hence their traversal is now fully incorporated. Basically this kind of builder only contains the akka.stream.impl.Traversal and only a couple of extra fields. * Linear builder with an incomplete composite at the end (output): In this case, we have an incomplete composite. It can only be at the end, since this is the only position where an output port can be unwired. We need to carry this builder with us until the output port is finally wired, in which case we incorporate its traversal into the already complete one, and hopefully transition to a purely linear builder.

    If we consider the purely linear case, we still need to figure out how can we provide a traversal even though the last output port is unwired. The trick that is used is to wire this output port optimistically to the relative address -1 which is almost always correct (why -1? explained a bit later). If it turns out to be incorrect later, we fix it by the helper method akka.stream.impl.Traversal.rewireFirstTo which tears down the traversal until the wrong module is found, then fixes the port assignment. This is only possible on purely linear layouts though. Again, this is an example of the 90% rule. Most appends will not need this rewiring and hence be as fast as possible while the rarer cases suffering a minor penalty.

    In the case where the last module is a composite, the above trick would not work as nothing guarantees that the module that exposed its output port is at an expected position in the traversal. Instead, we simply keep around this composite and delay construction of its part of the traversal. For details see akka.stream.impl.LinearTraversalBuilder as these cases are heavily commented and explained in the code.

    There is another peculiarity of the linear builder we need to explain. Namely, it builds the traversal in reverse order, i.e. from Sinks towards Sources. THIS CAN BE SUPER CONFUSING AT TIMES SO PAY ATTENTION! There are two important reasons why this is needed:

    * Prepending to immutable lists is more efficient. Even though we encode our traversal list as a tree, we would need stack space at materialization time as much as the length of the list if we would append to it instead of prepending. * Prepending means that most output ports refer to slots visited before, i.e. output relative offsets are negative. This means that during materialization, output ports will be wired to slots that the materializer visited before which enables an efficient one-pass materialization design. The importance of this is discussed later below.

    To visualize this, imagine a simple stream:

    [Source.out] -> [Map.in, Map.out] -> [Sink.in]

    The traversal:

    offs = 0 offs = 1 offs = 1 [Sink.in = 0] <- [Map.in = 1, Map.out = -1] <- [Source.out = -1]

    Since the traversal steps are reversed compared to the DSL order, it is important to reverse materialized value computation, too.

    Islands and local slots

    All what we have discussed so far referred to the "mental array", the global address space in which slots are assigned to ports. This model describes the wiring of the graph perfectly, but it does not map to the local data structures needed by materialization when there are islands present. One of the important goals of this layout data structure is to be able to produce the data structures used by the akka.stream.impl.fusing.GraphInterpreter directly, without much translation. Unfortunately if there is an island inside a traversal, it might leave gaps in the address space:

    |----Island1-----|----Island2(enclosed)----|-----Island1-----|

    Since we visit Island2 before returning to Island1, the naive approach would leave a large gap between the last input port visited before entering Island2 and the first input port visited when returning to Island1. What we would like to have instead is a contiguous slot assignment from the viewpoint of Island1. This is where akka.stream.impl.PhasedFusingActorMaterializer and its akka.stream.impl.IslandTracking helper comes into the picture. These classes do the heavy-lifting of traversing the traversal and then mapping global slots to slots local to the island, delegating then the local wiring to akka.stream.impl.PhaseIsland implementations. For example the akka.stream.impl.GraphStageIsland sees only a contigous slot-space and hence it can directly construct the array for the interpreter. It is not aware of the presence of other islands or how it is represented in the global slot-space.

    Materialization

    Materialzation is orchestrated by the akka.stream.impl.PhasedFusingActorMaterializer. It basically decodes the traversal and handles islands. This top-level materializer does not really handle the wiring _inside_ an island, it only handles wiring of Publishers and Subscribers that connect islands. Instead it delegates in-island wiring to akka.stream.impl.PhaseIslands. For example a default fused island will be actually wired by akka.stream.impl.GraphStageIsland.

    First, look at a traversal that has two islands:

    |----Island1-----|----Island2(enclosed)----|-----Island1-----|

    In this traversal, we have two islands, and three, so called _segments_. Segments are simply contiguous range of slots between akka.stream.impl.EnterIsland or akka.stream.impl.ExitIsland tags (in any combination). When the materializer encounters either an enter or exit command, it saves various information about the segment it just completed (what is its offset, how long it is measured in input slots, etc.). This information is later used to figure out if a wiring crosses island boundaries or is it local to the island.

    It is important to note that the data structure for this is only allocated when there are islands. This is again the 90% rule in action. In addition, these data structures are java.util.ArrayList instances, where lookups according to some value are implemented as simple linear scans. Since in 90% of the cases these structures are very short, this is the most efficient approach. Cases where this can be a performance problem are very-very special and likely not happen in practice (no graph should contain more than a dozen of islands for example).

    When it comes to deciding whether a wiring is cross-island or local, there are two cases possible:

    * we encountered an output port that is wired backwards (relative address is negative). In this case we already have all the data necessary to resolve the question. * we encountered an output port that is wired forward (relative address is positive). In this case we have not yet visited that part of the traversal where the assignment points.

    If we want to keep the one-pass design of the materializer, we need to delay forward wirings until we have all the information needed, i.e. we visit the target in port. The akka.stream.impl.PhasedFusingActorMaterializer has a data structure for tracking forward wires which it consults whenever it visits an input port. Again, this is only allocated if needed, and it is again an array with linear scan lookup. Once the target input port have been found, the rules of the wiring are the same as for backwards wiring.

    backward wire (to the visited part) <------+ +------> forward wire (into the unknown) | | |----Island1-----|----Island2(enclosed)-------- ... (this is where we are now)

    Remember, the akka.stream.impl.LinearTraversalBuilder builds its akka.stream.impl.Traversal in backwards order, so since most of the graphs are constructed by the linear DSLs almost all wirings will be backwards (90% rule in action again).

    Backward wirings

    When it comes to resolving wirings and calculating the local slots for all the islands involved there are three distinct cases.

    A wiring can be in-segment:

    +--------------+ | | |----Island1-----|----Island2(enclosed)----|-----Island1-----|

    This means that the slot assigned to the output port still belongs to the current segment. This is easy to detect as the akka.stream.impl.IslandTracking class tracks the offset of the current segment. If the target input slot is larger or equal than this offset, and the wiring is backwards, then the wiring is strictly local to the island. The materializer will simply delegate to the akka.stream.impl.PhaseIsland to do the internal wiring. Since we know the offset of the segment in the local space of this island, calculating the local slot for the akka.stream.impl.PhaseIsland is simple. (This is fully documented with diagrams in akka.stream.impl.IslandTracking)

    A wiring can be cross-segment, in-island:

    +---------------------------------+ | | |----Island1-----|----Island2(enclosed)----|-----Island1-----|

    In this case, the target slot is in another, but already visited segment. The akka.stream.impl.IslandTracking class needs to first find the segment in which the target slot is. Since each segment keeps a reference to its akka.stream.impl.PhaseIsland instance that handles the internal wiring a simple reference equality check will tell us if the target segment is in the same island or not. In this case it is, so all we need is to compensate for any possible holes (punched by enclosed islands) to calculate the local slot for the island and call the appropriate callback on the akka.stream.impl.PhaseIsland. (This is fully documented with diagrams in akka.stream.impl.IslandTracking)

    Finally a wiring can be cross-segment, cross-island:

    +------------------------+ | | |----Island1-----|----Island2(enclosed)----|-----Island1-----|

    This means, that the steps were similar as in the previous case until that point where we check the reference equality of the current akka.stream.impl.PhaseIsland with that of the target segment (we have already found the target segment). In this case, we need to calculate the local slot in the target island (similar to the previous case) and try to wire the two islands together. Now, instead of delegating the wiring to the phases, we ask the output akka.stream.impl.PhaseIsland to provide a Publisher and then we ask the target island to take this Publisher.

    Refer to akka.stream.impl.IslandTracking for all the nasty details of local slot resolution. It is also recommended to try out a few examples with akka.stream.impl.PhasedFusingActorMaterializer.Debug turned on, it will detail every step of the island tracking and slot resolution steps.

    Utilities

    Useful utilities are:

    * akka.stream.impl.PhasedFusingActorMaterializer.Debug: if this flag is turned on, the materializer will log the steps it takes * akka.stream.impl.TraversalBuilder.printTraversal: Prints the Traversal in a readable format * akka.stream.impl.TraversalBuilder.printWiring: Prints the calculated port assignments. Useful for debugging if everything is wired to the right thing.

    Definition Classes
    stream
  • package javadsl
    Definition Classes
    stream
  • package scaladsl

    Scala API: The flow DSL allows the formulation of stream transformations based on some input.

    Scala API: The flow DSL allows the formulation of stream transformations based on some input. The starting point is called Source and can be a collection, an iterator, a block of code which is evaluated repeatedly or a org.reactivestreams.Publisher. A flow with an attached input and open output is also a Source.

    A flow may also be defined without an attached input or output and that is then a Flow. The Flow can be connected to the Source later by using Source#via with the flow as argument, and it remains a Source.

    Transformations can be appended to Source and Flow with the operations defined in FlowOps. Each DSL element produces a new flow that can be further transformed, building up a description of the complete transformation pipeline.

    The termination point of a flow is called Sink and can for example be a Future or org.reactivestreams.Subscriber. A flow with an attached output and open input is also a Sink.

    If a flow has both an attached input and an attached output it becomes a RunnableGraph. In order to execute this pipeline the flow must be materialized by calling RunnableGraph#run on it.

    You can create your Source, Flow and Sink in any order and then wire them together before they are materialized by connecting them using Flow#via and Flow#to, or connecting them into a GraphDSL with fan-in and fan-out elements.

    See Reactive Streams for details on org.reactivestreams.Publisher and org.reactivestreams.Subscriber.

    It should be noted that the streams modeled by this library are “hot”, meaning that they asynchronously flow through a series of processors without detailed control by the user. In particular it is not predictable how many elements a given transformation step might buffer before handing elements downstream, which means that transformation functions may be invoked more often than for corresponding transformations on strict collections like List. *An important consequence* is that elements that were produced into a stream may be discarded by later processors, e.g. when using the #take operator.

    By default every operation is executed within its own akka.actor.Actor to enable full pipelining of the chained set of computations. This behavior is determined by the akka.stream.Materializer which is required by those methods that materialize the Flow into a series of org.reactivestreams.Processor instances. The returned reactive stream is fully started and active.

    Definition Classes
    stream
  • package snapshot
    Definition Classes
    stream
  • package stage
    Definition Classes
    stream
  • package testkit
    Definition Classes
    stream
  • package typed
    Definition Classes
    stream
  • AbruptIOTerminationException
  • AbruptStageTerminationException
  • AbruptStreamTerminationException
  • AbruptTerminationException
  • AbstractShape
  • ActorAttributes
  • ActorMaterializer
  • ActorMaterializerSettings
  • AmorphousShape
  • Attributes
  • BackpressureTimeoutException
  • BidiShape
  • BindFailedException
  • BoundedSourceQueue
  • BufferOverflowException
  • Client
  • ClosedShape
  • CompletionStrategy
  • CompletionTimeoutException
  • ConnectionException
  • DelayOverflowStrategy
  • EagerClose
  • FanInShape
  • FanInShape10
  • FanInShape11
  • FanInShape12
  • FanInShape13
  • FanInShape14
  • FanInShape15
  • FanInShape16
  • FanInShape17
  • FanInShape18
  • FanInShape19
  • FanInShape2
  • FanInShape20
  • FanInShape21
  • FanInShape22
  • FanInShape3
  • FanInShape4
  • FanInShape5
  • FanInShape6
  • FanInShape7
  • FanInShape8
  • FanInShape9
  • FanOutShape
  • FanOutShape10
  • FanOutShape11
  • FanOutShape12
  • FanOutShape13
  • FanOutShape14
  • FanOutShape15
  • FanOutShape16
  • FanOutShape17
  • FanOutShape18
  • FanOutShape19
  • FanOutShape2
  • FanOutShape20
  • FanOutShape21
  • FanOutShape22
  • FanOutShape3
  • FanOutShape4
  • FanOutShape5
  • FanOutShape6
  • FanOutShape7
  • FanOutShape8
  • FanOutShape9
  • FlowMonitor
  • FlowMonitorState
  • FlowShape
  • Graph
  • IOOperationIncompleteException
  • IOResult
  • IOSettings
  • IgnoreBoth
  • IgnoreCancel
  • IgnoreComplete
  • InPort
  • InitialTimeoutException
  • Inlet
  • InvalidPartnerActorException
  • InvalidSequenceNumberException
  • KillSwitch
  • KillSwitches
  • MaterializationException
  • Materializer
  • MaterializerLoggingProvider
  • NeverMaterializedException
  • OutPort
  • Outlet
  • OverflowStrategy
  • QueueCompletionResult
  • QueueOfferResult
  • RateExceededException
  • RemoteStreamRefActorTerminatedException
  • RestartSettings
  • Server
  • Shape
  • SharedKillSwitch
  • SinkRef
  • SinkShape
  • SourceRef
  • SourceShape
  • StreamDetachedException
  • StreamIdleTimeoutException
  • StreamLimitReachedException
  • StreamRefAttributes
  • StreamRefMessages
  • StreamRefResolver
  • StreamRefSettings
  • StreamRefSubscriptionTimeoutException
  • StreamSubscriptionTimeoutSettings
  • StreamSubscriptionTimeoutTerminationMode
  • StreamTcpException
  • StreamTimeoutException
  • SubscriptionWithCancelException
  • SubstreamCancelStrategy
  • Supervision
  • SystemMaterializer
  • TLSClientAuth
  • TLSClosing
  • TLSProtocol
  • TLSRole
  • TargetRefNotInitializedYetException
  • ThrottleMode
  • TooManySubstreamsOpenException
  • UniformFanInShape
  • UniformFanOutShape
  • UniqueKillSwitch
  • WatchedActorTerminatedException

trait SourceRef[T] extends AnyRef

A SourceRef allows sharing a "reference" with others, with the main purpose of crossing a network boundary. Usually obtaining a SourceRef would be done via Actor messaging, in which one system asks a remote one, to share some data with it, and the remote one decides to do so in a back-pressured streaming fashion -- using a stream ref.

To create a SourceRef you have to materialize the Source that you want to obtain a reference to by attaching it to a Sink.sourceRef.

Stream refs can be seen as Reactive Streams over network boundaries. See also akka.stream.SinkRef which is the dual of a SourceRef.

For additional configuration see reference.conf as well as akka.stream.StreamRefAttributes.

Not for user extension.

Annotations
@DoNotInherit()
Source
StreamRefs.scala
Linear Supertypes
AnyRef, Any
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. SourceRef
  2. AnyRef
  3. Any
Implicitly
  1. by convertRefToSource
  2. by any2stringadd
  3. by StringFormat
  4. by Ensuring
  5. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Abstract Value Members

  1. abstract def source: Source[T, NotUsed]

    Scala API: Get Source underlying to this source ref.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. def +(other: String): String
    Implicit
    This member is added by an implicit conversion from SourceRef[T] toany2stringadd[SourceRef[T]] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ++[U >: Out, M](that: Graph[SourceShape[U], M]): Source[U, NotUsed]

    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.

    This is a shorthand for concat

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  5. def ->[B](y: B): (SourceRef[T], B)
    Implicit
    This member is added by an implicit conversion from SourceRef[T] toArrowAssoc[SourceRef[T]] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  6. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. def addAttributes(attr: Attributes): Source[T, NotUsed]

    Add the given attributes to this Source.

    Add the given attributes to this Source. If the specific attribute was already on this source it will replace the previous value. If this Source is a composite of multiple graphs, the added attributes will be on the composite and therefore less specific than attributes set directly on the individual graphs of the composite.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → Graph → FlowOps
  8. def aggregateWithBoundary[Agg, Emit](allocate: () => Agg)(aggregate: (Agg, T) => (Agg, Boolean), harvest: (Agg) => Emit, emitOnTimer: Option[((Agg) => Boolean, FiniteDuration)]): Source[Emit, NotUsed]

    Aggregate input elements into an arbitrary data structure that can be completed and emitted downstream when custom condition is met which can be triggered by aggregate or timer.

    Aggregate input elements into an arbitrary data structure that can be completed and emitted downstream when custom condition is met which can be triggered by aggregate or timer. It can be thought of a more general groupedWeightedWithin.

    Emits when the aggregation function decides the aggregate is complete or the timer function returns true

    Backpressures when downstream backpressures and the aggregate is complete

    Completes when upstream completes and the last aggregate has been emitted downstream

    Cancels when downstream cancels

    allocate

    allocate the initial data structure for aggregated elements

    aggregate

    update the aggregated elements, return true if ready to emit after update.

    harvest

    this is invoked before emit within the current stage/operator

    emitOnTimer

    decide whether the current aggregated elements can be emitted, the custom function is invoked on every interval

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    Annotations
    @ApiMayChange()
  9. def alsoTo(that: Graph[SinkShape[T], _]): Source[T, NotUsed]

    Attaches the given Sink to this Source, meaning that elements that pass through will also be sent to the Sink.

    Attaches the given Sink to this Source, meaning that elements that pass through will also be sent to the Sink.

    It is similar to #wireTap but will backpressure instead of dropping elements when the given Sink is not ready.

    Emits when element is available and demand exists both from the Sink and the downstream.

    Backpressures when downstream or Sink backpressures

    Completes when upstream completes

    Cancels when downstream or Sink cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  10. def alsoToAll(those: Graph[SinkShape[T], _]*): Source[T, NotUsed]

    Attaches the given Sinks to this Source, meaning that elements that pass through will also be sent to the Sink.

    Attaches the given Sinks to this Source, meaning that elements that pass through will also be sent to the Sink.

    It is similar to #wireTap but will backpressure instead of dropping elements when the given Sinks is not ready.

    Emits when element is available and demand exists both from the Sinks and the downstream.

    Backpressures when downstream or any of the Sinks backpressures

    Completes when upstream completes

    Cancels when downstream or any of the Sinks cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  11. def alsoToMat[Mat2, Mat3](that: Graph[SinkShape[T], Mat2])(matF: (NotUsed, Mat2) => Mat3): Source[T, Mat3]

    Attaches the given Sink to this Flow, meaning that elements that pass through will also be sent to the Sink.

    Attaches the given Sink to this Flow, meaning that elements that pass through will also be sent to the Sink.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #alsoTo It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  12. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  13. def asJava: Source[T, NotUsed]

    Converts this Scala DSL element to it's Java DSL counterpart.

    Converts this Scala DSL element to it's Java DSL counterpart.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source
  14. def asSourceWithContext[Ctx](f: (T) => Ctx): SourceWithContext[T, Ctx, NotUsed]

    Transform this source whose element is e into a source producing tuple (e, f(e))

    Transform this source whose element is e into a source producing tuple (e, f(e))

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source
  15. def ask[S](parallelism: Int)(ref: ActorRef)(implicit timeout: Timeout, tag: ClassTag[S]): Source[S, NotUsed]

    Use the ask pattern to send a request-reply message to the target ref actor.

    Use the ask pattern to send a request-reply message to the target ref actor. If any of the asks times out it will fail the stream with a akka.pattern.AskTimeoutException.

    Do not forget to include the expected response type in the method call, like so:

    flow.ask[ExpectedReply](parallelism = 4)(ref)

    otherwise Nothing will be assumed, which is most likely not what you want.

    Parallelism limits the number of how many asks can be "in flight" at the same time. Please note that the elements emitted by this operator are in-order with regards to the asks being issued (i.e. same behaviour as mapAsync).

    The operator fails with an akka.stream.WatchedActorTerminatedException if the target actor is terminated, or with an java.util.concurrent.TimeoutException in case the ask exceeds the timeout passed in.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the futures (in submission order) created by the ask pattern internally are completed

    Backpressures when the number of futures reaches the configured parallelism and the downstream backpressures

    Completes when upstream completes and all futures have been completed and all elements have been emitted

    Fails when the passed in actor terminates, or a timeout is exceeded in any of the asks performed

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    Annotations
    @implicitNotFound()
  16. def ask[S](ref: ActorRef)(implicit timeout: Timeout, tag: ClassTag[S]): Source[S, NotUsed]

    Use the ask pattern to send a request-reply message to the target ref actor.

    Use the ask pattern to send a request-reply message to the target ref actor. If any of the asks times out it will fail the stream with a akka.pattern.AskTimeoutException.

    Do not forget to include the expected response type in the method call, like so:

    flow.ask[ExpectedReply](ref)

    otherwise Nothing will be assumed, which is most likely not what you want.

    Defaults to parallelism of 2 messages in flight, since while one ask message may be being worked on, the second one still be in the mailbox, so defaulting to sending the second one a bit earlier than when first ask has replied maintains a slightly healthier throughput.

    Similar to the plain ask pattern, the target actor is allowed to reply with akka.util.Status. An akka.util.Status#Failure will cause the operator to fail with the cause carried in the Failure message.

    The operator fails with an akka.stream.WatchedActorTerminatedException if the target actor is terminated.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the futures (in submission order) created by the ask pattern internally are completed

    Backpressures when the number of futures reaches the configured parallelism and the downstream backpressures

    Completes when upstream completes and all futures have been completed and all elements have been emitted

    Fails when the passed in actor terminates, or a timeout is exceeded in any of the asks performed

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    Annotations
    @implicitNotFound()
  17. def async(dispatcher: String, inputBufferSize: Int): Source[T, NotUsed]

    Put an asynchronous boundary around this Graph

    Put an asynchronous boundary around this Graph

    dispatcher

    Run the graph on this dispatcher

    inputBufferSize

    Set the input buffer to this size for the graph

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → Graph
  18. def async(dispatcher: String): Source[T, NotUsed]

    Put an asynchronous boundary around this Graph

    Put an asynchronous boundary around this Graph

    dispatcher

    Run the graph on this dispatcher

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → Graph
  19. def async: Source[T, NotUsed]

    Put an asynchronous boundary around this Source

    Put an asynchronous boundary around this Source

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → Graph → FlowOps
  20. def backpressureTimeout(timeout: FiniteDuration): Source[T, NotUsed]

    If the time between the emission of an element and the following downstream demand exceeds the provided timeout, the stream is failed with a akka.stream.BackpressureTimeoutException.

    If the time between the emission of an element and the following downstream demand exceeds the provided timeout, the stream is failed with a akka.stream.BackpressureTimeoutException. The timeout is checked periodically, so the resolution of the check is one period (equals to timeout value).

    Emits when upstream emits an element

    Backpressures when downstream backpressures

    Completes when upstream completes or fails if timeout elapses between element emission and downstream demand.

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  21. def batch[S](max: Long, seed: (T) => S)(aggregate: (S, T) => S): Source[S, NotUsed]

    Allows a faster upstream to progress independently of a slower subscriber by aggregating elements into batches until the subscriber is ready to accept them.

    Allows a faster upstream to progress independently of a slower subscriber by aggregating elements into batches until the subscriber is ready to accept them. For example a batch step might store received elements in an array up to the allowed max limit if the upstream publisher is faster.

    This only rolls up elements if the upstream is faster, but if the downstream is faster it will not duplicate elements.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when downstream stops backpressuring and there is an aggregated element available

    Backpressures when there are max batched elements and 1 pending element and downstream backpressures

    Completes when upstream completes and there is no batched/pending element waiting

    Cancels when downstream cancels

    See also FlowOps.conflateWithSeed, FlowOps.batchWeighted

    max

    maximum number of elements to batch before backpressuring upstream (must be positive non-zero)

    seed

    Provides the first state for a batched value using the first unconsumed element as a start

    aggregate

    Takes the currently batched value and the current pending element to produce a new aggregate

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  22. def batchWeighted[S](max: Long, costFn: (T) => Long, seed: (T) => S)(aggregate: (S, T) => S): Source[S, NotUsed]

    Allows a faster upstream to progress independently of a slower subscriber by aggregating elements into batches until the subscriber is ready to accept them.

    Allows a faster upstream to progress independently of a slower subscriber by aggregating elements into batches until the subscriber is ready to accept them. For example a batch step might concatenate ByteString elements up to the allowed max limit if the upstream publisher is faster.

    This element only rolls up elements if the upstream is faster, but if the downstream is faster it will not duplicate elements.

    Batching will apply for all elements, even if a single element cost is greater than the total allowed limit. In this case, previous batched elements will be emitted, then the "heavy" element will be emitted (after being applied with the seed function) without batching further elements with it, and then the rest of the incoming elements are batched.

    Emits when downstream stops backpressuring and there is a batched element available

    Backpressures when there are max weighted batched elements + 1 pending element and downstream backpressures

    Completes when upstream completes and there is no batched/pending element waiting

    Cancels when downstream cancels

    See also FlowOps.conflateWithSeed, FlowOps.batch

    max

    maximum weight of elements to batch before backpressuring upstream (must be positive non-zero)

    costFn

    a function to compute a single element weight

    seed

    Provides the first state for a batched value using the first unconsumed element as a start

    aggregate

    Takes the currently batched value and the current pending element to produce a new batch

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  23. def buffer(size: Int, overflowStrategy: OverflowStrategy): Source[T, NotUsed]

    Adds a fixed size buffer in the flow that allows to store elements from a faster upstream until it becomes full.

    Adds a fixed size buffer in the flow that allows to store elements from a faster upstream until it becomes full. Depending on the defined akka.stream.OverflowStrategy it might drop elements or backpressure the upstream if there is no space available

    Emits when downstream stops backpressuring and there is a pending element in the buffer

    Backpressures when downstream backpressures or depending on OverflowStrategy:

    • Backpressure - backpressures when buffer is full
    • DropHead, DropTail, DropBuffer - never backpressures
    • Fail - fails the stream if buffer gets full

    Completes when upstream completes and buffered elements have been drained

    Cancels when downstream cancels

    size

    The size of the buffer in element count

    overflowStrategy

    Strategy that is used when incoming elements cannot fit inside the buffer

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  24. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @HotSpotIntrinsicCandidate() @native()
  25. def collect[T](pf: PartialFunction[T, T]): Source[T, NotUsed]

    Transform this stream by applying the given partial function to each of the elements on which the function is defined as they pass through this processing step.

    Transform this stream by applying the given partial function to each of the elements on which the function is defined as they pass through this processing step. Non-matching elements are filtered out.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the provided partial function is defined for the element

    Backpressures when the partial function is defined for the element and downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  26. def collectType[T](implicit tag: ClassTag[T]): Source[T, NotUsed]

    Transform this stream by testing the type of each of the elements on which the element is an instance of the provided type as they pass through this processing step.

    Transform this stream by testing the type of each of the elements on which the element is an instance of the provided type as they pass through this processing step.

    Non-matching elements are filtered out.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the element is an instance of the provided type

    Backpressures when the element is an instance of the provided type and downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  27. def completionTimeout(timeout: FiniteDuration): Source[T, NotUsed]

    If the completion of the stream does not happen until the provided timeout, the stream is failed with a akka.stream.CompletionTimeoutException.

    If the completion of the stream does not happen until the provided timeout, the stream is failed with a akka.stream.CompletionTimeoutException.

    Emits when upstream emits an element

    Backpressures when downstream backpressures

    Completes when upstream completes or fails if timeout elapses before upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  28. def concat[U >: Out, Mat2](that: Graph[SourceShape[U], Mat2]): Source[U, NotUsed]

    Concatenate the given Source to this Flow, meaning that once this Flow’s input is exhausted and all result elements have been generated, the Source’s elements will be produced.

    Concatenate the given Source to this Flow, meaning that once this Flow’s input is exhausted and all result elements have been generated, the Source’s elements will be produced.

    Note that the Source is materialized together with this Flow and is "detached" meaning it will in effect behave as a one element buffer in front of both the sources, that eagerly demands an element on start (so it can not be combined with Source.lazy to defer materialization of that).

    The second source is then kept from producing elements by asserting back-pressure until its time comes.

    When needing a concat operator that is not detached use #concatLazy

    If this Flow gets upstream error - no elements from the given Source will be pulled.

    Emits when element is available from current stream or from the given Source when current is completed

    Backpressures when downstream backpressures

    Completes when given Source completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  29. def concatAllLazy[U >: Out](those: Graph[SourceShape[U], _]*): Source[U, NotUsed]

    Concatenate the given Sources to this Flow, meaning that once this Flow’s input is exhausted and all result elements have been generated, the Sources' elements will be produced.

    Concatenate the given Sources to this Flow, meaning that once this Flow’s input is exhausted and all result elements have been generated, the Sources' elements will be produced.

    Note that the Sources are materialized together with this Flow. If lazy materialization is what is needed the operator can be combined with for example Source.lazySource to defer materialization of that until the time when this source completes.

    The second source is then kept from producing elements by asserting back-pressure until its time comes.

    For a concat operator that is detached, use #concat

    If this Flow gets upstream error - no elements from the given Sources will be pulled.

    Emits when element is available from current stream or from the given Sources when current is completed

    Backpressures when downstream backpressures

    Completes when given all those Sources completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  30. def concatLazy[U >: Out, Mat2](that: Graph[SourceShape[U], Mat2]): Source[U, NotUsed]

    Concatenate the given Source to this Flow, meaning that once this Flow’s input is exhausted and all result elements have been generated, the Source’s elements will be produced.

    Concatenate the given Source to this Flow, meaning that once this Flow’s input is exhausted and all result elements have been generated, the Source’s elements will be produced.

    Note that the Source is materialized together with this Flow. If lazy materialization is what is needed the operator can be combined with for example Source.lazySource to defer materialization of that until the time when this source completes.

    The second source is then kept from producing elements by asserting back-pressure until its time comes.

    For a concat operator that is detached, use #concat

    If this Flow gets upstream error - no elements from the given Source will be pulled.

    Emits when element is available from current stream or from the given Source when current is completed

    Backpressures when downstream backpressures

    Completes when given Source completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  31. def concatLazyMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2])(matF: (NotUsed, Mat2) => Mat3): Source[U, Mat3]

    Concatenate the given Source to this Flow, meaning that once this Flow’s input is exhausted and all result elements have been generated, the Source’s elements will be produced.

    Concatenate the given Source to this Flow, meaning that once this Flow’s input is exhausted and all result elements have been generated, the Source’s elements will be produced.

    Note that the Source is materialized together with this Flow, if lazy materialization is what is needed the operator can be combined with Source.lazy to defer materialization of that.

    The second source is then kept from producing elements by asserting back-pressure until its time comes.

    For a concat operator that is detached, use #concatMat

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #concatLazy. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  32. def concatMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2])(matF: (NotUsed, Mat2) => Mat3): Source[U, Mat3]

    Concatenate the given Source to this Flow, meaning that once this Flow’s input is exhausted and all result elements have been generated, the Source’s elements will be produced.

    Concatenate the given Source to this Flow, meaning that once this Flow’s input is exhausted and all result elements have been generated, the Source’s elements will be produced.

    Note that the Source is materialized together with this Flow and is "detached" meaning it will in effect behave as a one element buffer in front of both the sources, that eagerly demands an element on start (so it can not be combined with Source.lazy to defer materialization of that).

    The second source is then kept from producing elements by asserting back-pressure until its time comes.

    When needing a concat operator that is not detached use #concatLazyMat

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #concat. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  33. def conflate[O2 >: Out](aggregate: (O2, O2) => O2): Source[O2, NotUsed]

    Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary until the subscriber is ready to accept them.

    Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary until the subscriber is ready to accept them. For example a conflate step might average incoming numbers if the upstream publisher is faster.

    This version of conflate does not change the output type of the stream. See FlowOps.conflateWithSeed for a more flexible version that can take a seed function and transform elements while rolling up.

    This element only rolls up elements if the upstream is faster, but if the downstream is faster it will not duplicate elements.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when downstream stops backpressuring and there is a conflated element available

    Backpressures when never

    Completes when upstream completes

    Cancels when downstream cancels

    aggregate

    Takes the currently aggregated value and the current pending element to produce a new aggregate See also FlowOps.conflate, FlowOps.limit, FlowOps.limitWeighted FlowOps.batch FlowOps.batchWeighted

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  34. def conflateWithSeed[S](seed: (T) => S)(aggregate: (S, T) => S): Source[S, NotUsed]

    Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary until the subscriber is ready to accept them.

    Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary until the subscriber is ready to accept them. For example a conflate step might average incoming numbers if the upstream publisher is faster.

    This version of conflate allows to derive a seed from the first element and change the aggregated type to be different than the input type. See FlowOps.conflate for a simpler version that does not change types.

    This element only rolls up elements if the upstream is faster, but if the downstream is faster it will not duplicate elements.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when downstream stops backpressuring and there is a conflated element available

    Backpressures when never

    Completes when upstream completes

    Cancels when downstream cancels

    seed

    Provides the first state for a conflated value using the first unconsumed element as a start

    aggregate

    Takes the currently aggregated value and the current pending element to produce a new aggregate See also FlowOps.conflate, FlowOps.limit, FlowOps.limitWeighted FlowOps.batch FlowOps.batchWeighted

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  35. def delay(of: FiniteDuration, strategy: DelayOverflowStrategy = DelayOverflowStrategy.dropTail): Source[T, NotUsed]

    Shifts elements emission in time by a specified amount.

    Shifts elements emission in time by a specified amount. It allows to store elements in internal buffer while waiting for next element to be emitted. Depending on the defined akka.stream.DelayOverflowStrategy it might drop elements or backpressure the upstream if there is no space available in the buffer.

    Delay precision is 10ms to avoid unnecessary timer scheduling cycles

    Internal buffer has default capacity 16. You can set buffer size by calling addAttributes(inputBuffer)

    Emits when there is a pending element in the buffer and configured time for this element elapsed * EmitEarly - strategy do not wait to emit element if buffer is full

    Backpressures when depending on OverflowStrategy * Backpressure - backpressures when buffer is full * DropHead, DropTail, DropBuffer - never backpressures * Fail - fails the stream if buffer gets full

    Completes when upstream completes and buffered elements have been drained

    Cancels when downstream cancels

    of

    time to shift all messages

    strategy

    Strategy that is used when incoming elements cannot fit inside the buffer

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  36. def delayWith(delayStrategySupplier: () => DelayStrategy[T], overFlowStrategy: DelayOverflowStrategy): Source[T, NotUsed]

    Shifts elements emission in time by an amount individually determined through delay strategy a specified amount.

    Shifts elements emission in time by an amount individually determined through delay strategy a specified amount. It allows to store elements in internal buffer while waiting for next element to be emitted. Depending on the defined akka.stream.DelayOverflowStrategy it might drop elements or backpressure the upstream if there is no space available in the buffer.

    It determines delay for each ongoing element invoking DelayStrategy.nextDelay(elem: T): FiniteDuration.

    Note that elements are not re-ordered: if an element is given a delay much shorter than its predecessor, it will still have to wait for the preceding element before being emitted. It is also important to notice that scaladsl.DelayStrategy can be stateful.

    Delay precision is 10ms to avoid unnecessary timer scheduling cycles.

    Internal buffer has default capacity 16. You can set buffer size by calling addAttributes(inputBuffer)

    Emits when there is a pending element in the buffer and configured time for this element elapsed * EmitEarly - strategy do not wait to emit element if buffer is full

    Backpressures when depending on OverflowStrategy * Backpressure - backpressures when buffer is full * DropHead, DropTail, DropBuffer - never backpressures * Fail - fails the stream if buffer gets full

    Completes when upstream completes and buffered elements have been drained

    Cancels when downstream cancels

    delayStrategySupplier

    creates new DelayStrategy object for each materialization

    overFlowStrategy

    Strategy that is used when incoming elements cannot fit inside the buffer

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  37. def detach: Source[T, NotUsed]

    Detaches upstream demand from downstream demand without detaching the stream rates; in other words acts like a buffer of size 1.

    Detaches upstream demand from downstream demand without detaching the stream rates; in other words acts like a buffer of size 1.

    Emits when upstream emits an element

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  38. def divertTo(that: Graph[SinkShape[T], _], when: (T) => Boolean): Source[T, NotUsed]

    Attaches the given Sink to this Flow, meaning that elements will be sent to the Sink instead of being passed through if the predicate when returns true.

    Attaches the given Sink to this Flow, meaning that elements will be sent to the Sink instead of being passed through if the predicate when returns true.

    Emits when emits when an element is available from the input and the chosen output has demand

    Backpressures when the currently chosen output back-pressures

    Completes when upstream completes and no output is pending

    Cancels when any of the downstreams cancel

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  39. def divertToMat[Mat2, Mat3](that: Graph[SinkShape[T], Mat2], when: (T) => Boolean)(matF: (NotUsed, Mat2) => Mat3): Source[T, Mat3]

    Attaches the given Sink to this Flow, meaning that elements will be sent to the Sink instead of being passed through if the predicate when returns true.

    Attaches the given Sink to this Flow, meaning that elements will be sent to the Sink instead of being passed through if the predicate when returns true.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #divertTo It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  40. def drop(n: Long): Source[T, NotUsed]

    Discard the given number of elements at the beginning of the stream.

    Discard the given number of elements at the beginning of the stream. No elements will be dropped if n is zero or negative.

    Emits when the specified number of elements has been dropped already

    Backpressures when the specified number of elements has been dropped and downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  41. def dropWhile(p: (T) => Boolean): Source[T, NotUsed]

    Discard elements at the beginning of the stream while predicate is true.

    Discard elements at the beginning of the stream while predicate is true. All elements will be taken after predicate returns false first time.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when predicate returned false and for all following stream elements

    Backpressures when predicate returned false and downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  42. def dropWithin(d: FiniteDuration): Source[T, NotUsed]

    Discard the elements received within the given duration at beginning of the stream.

    Discard the elements received within the given duration at beginning of the stream.

    Emits when the specified time elapsed and a new upstream element arrives

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  43. def ensuring(cond: (SourceRef[T]) => Boolean, msg: => Any): SourceRef[T]
    Implicit
    This member is added by an implicit conversion from SourceRef[T] toEnsuring[SourceRef[T]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  44. def ensuring(cond: (SourceRef[T]) => Boolean): SourceRef[T]
    Implicit
    This member is added by an implicit conversion from SourceRef[T] toEnsuring[SourceRef[T]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  45. def ensuring(cond: Boolean, msg: => Any): SourceRef[T]
    Implicit
    This member is added by an implicit conversion from SourceRef[T] toEnsuring[SourceRef[T]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  46. def ensuring(cond: Boolean): SourceRef[T]
    Implicit
    This member is added by an implicit conversion from SourceRef[T] toEnsuring[SourceRef[T]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  47. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  48. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  49. def expand[U](expander: (T) => Iterator[U]): Source[U, NotUsed]

    Allows a faster downstream to progress independently of a slower upstream by extrapolating elements from an older element until new element comes from the upstream.

    Allows a faster downstream to progress independently of a slower upstream by extrapolating elements from an older element until new element comes from the upstream. For example an expand step might repeat the last element for the subscriber until it receives an update from upstream.

    This element will never "drop" upstream elements as all elements go through at least one extrapolation step. This means that if the upstream is actually faster than the upstream it will be backpressured by the downstream subscriber.

    Expand does not support akka.stream.Supervision.Restart and akka.stream.Supervision.Resume. Exceptions from the seed function will complete the stream with failure.

    Emits when downstream stops backpressuring

    Backpressures when downstream backpressures or iterator runs empty

    Completes when upstream completes

    Cancels when downstream cancels

    expander

    Takes the current extrapolation state to produce an output element and the next extrapolation state.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    See also

    #extrapolate for a version that always preserves the original element and allows for an initial "startup" element.

  50. def extrapolate[U >: Out](extrapolator: (U) => Iterator[U], initial: Option[U] = None): Source[U, NotUsed]

    Allows a faster downstream to progress independent of a slower upstream.

    Allows a faster downstream to progress independent of a slower upstream.

    This is achieved by introducing "extrapolated" elements - based on those from upstream - whenever downstream signals demand.

    Extrapolate does not support akka.stream.Supervision.Restart and akka.stream.Supervision.Resume. Exceptions from the extrapolate function will complete the stream with failure.

    Emits when downstream stops backpressuring, AND EITHER upstream emits OR initial element is present OR extrapolate is non-empty and applicable

    Backpressures when downstream backpressures or current extrapolate runs empty

    Completes when upstream completes and current extrapolate runs empty

    Cancels when downstream cancels

    extrapolator

    takes the current upstream element and provides a sequence of "extrapolated" elements based on the original, to be emitted in case downstream signals demand.

    initial

    the initial element to be emitted, in case upstream is able to stall the entire stream.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    See also

    #expand for a version that can overwrite the original element.

  51. def filter(p: (T) => Boolean): Source[T, NotUsed]

    Only pass on those elements that satisfy the given predicate.

    Only pass on those elements that satisfy the given predicate.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the given predicate returns true for the element

    Backpressures when the given predicate returns true for the element and downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  52. def filterNot(p: (T) => Boolean): Source[T, NotUsed]

    Only pass on those elements that NOT satisfy the given predicate.

    Only pass on those elements that NOT satisfy the given predicate.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the given predicate returns false for the element

    Backpressures when the given predicate returns false for the element and downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  53. def flatMapConcat[T, M](f: (T) => Graph[SourceShape[T], M]): Source[T, NotUsed]

    Transform each input element into a Source of output elements that is then flattened into the output stream by concatenation, fully consuming one Source after the other.

    Transform each input element into a Source of output elements that is then flattened into the output stream by concatenation, fully consuming one Source after the other.

    Emits when a currently consumed substream has an element available

    Backpressures when downstream backpressures

    Completes when upstream completes and all consumed substreams complete

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  54. def flatMapMerge[T, M](breadth: Int, f: (T) => Graph[SourceShape[T], M]): Source[T, NotUsed]

    Transform each input element into a Source of output elements that is then flattened into the output stream by merging, where at most breadth substreams are being consumed at any given time.

    Transform each input element into a Source of output elements that is then flattened into the output stream by merging, where at most breadth substreams are being consumed at any given time.

    Emits when a currently consumed substream has an element available

    Backpressures when downstream backpressures

    Completes when upstream completes and all consumed substreams complete

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  55. def flatMapPrefix[Out2, Mat2](n: Int)(f: (Seq[T]) => Flow[T, Out2, Mat2]): Source[Out2, NotUsed]

    Takes up to n elements from the stream (less than n only if the upstream completes before emitting n elements), then apply f on these elements in order to obtain a flow, this flow is then materialized and the rest of the input is processed by this flow (similar to via).

    Takes up to n elements from the stream (less than n only if the upstream completes before emitting n elements), then apply f on these elements in order to obtain a flow, this flow is then materialized and the rest of the input is processed by this flow (similar to via). This method returns a flow consuming the rest of the stream producing the materialized flow's output.

    Emits when the materialized flow emits. Notice the first n elements are buffered internally before materializing the flow and connecting it to the rest of the upstream - producing elements at its own discretion (might 'swallow' or multiply elements).

    Backpressures when the materialized flow backpressures

    Completes when the materialized flow completes. If upstream completes before producing n elements, f will be applied with the provided elements, the resulting flow will be materialized and signalled for upstream completion, it can then complete or continue to emit elements at its own discretion.

    Cancels when the materialized flow cancels. When downstream cancels before materialization of the nested flow, the operator's default behaviour is to cancel immediately, this behaviour can be controlled by setting the akka.stream.Attributes.NestedMaterializationCancellationPolicy attribute on the flow. When this attribute is configured to true, downstream cancellation is delayed until the nested flow's materialization which is then immediately cancelled (with the original cancellation cause).

    n

    the number of elements to accumulate before materializing the downstream flow.

    f

    a function that produces the downstream flow based on the upstream's prefix.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  56. def flatMapPrefixMat[Out2, Mat2, Mat3](n: Int)(f: (Seq[T]) => Flow[T, Out2, Mat2])(matF: (NotUsed, Future[Mat2]) => Mat3): Source[Out2, Mat3]

    mat version of #flatMapPrefix, this method gives access to a future materialized value of the downstream flow.

    mat version of #flatMapPrefix, this method gives access to a future materialized value of the downstream flow. see #flatMapPrefix for details.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
  57. def fold[T](zero: T)(f: (T, T) => T): Source[T, NotUsed]

    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.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Note that the zero value must be immutable.

    Emits when upstream completes

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    See also FlowOps.scan

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  58. def foldAsync[T](zero: T)(f: (T, T) => Future[T]): Source[T, NotUsed]

    Similar to fold but with an asynchronous function.

    Similar to fold but with an asynchronous function. Applies the given function towards its current and next value, yielding the next current value.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    If the function f returns a failure and the supervision decision is akka.stream.Supervision.Restart current value starts at zero again the stream will continue.

    Note that the zero value must be immutable.

    Emits when upstream completes

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    See also FlowOps.fold

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  59. def getAttributes: Attributes
    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → Graph
  60. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  61. final def getSource: Source[T, NotUsed]

    Java API: Get javadsl.Source underlying to this source ref.

  62. def groupBy[K](maxSubstreams: Int, f: (T) => K): SubFlow[T, NotUsed, [+O]Source[O, NotUsed], RunnableGraph[NotUsed]]

    This operation demultiplexes the incoming stream into separate output streams, one for each element key.

    This operation demultiplexes the incoming stream into separate output streams, one for each element key. The key is computed for each element using the given function. When a new key is encountered for the first time a new substream is opened and subsequently fed with all elements belonging to that key.

    WARNING: The operator keeps track of all keys of streams that have already been closed. If you expect an infinite number of keys this can cause memory issues. Elements belonging to those keys are drained directly and not send to the substream.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    See also

    #groupBy

  63. def groupBy[K](maxSubstreams: Int, f: (T) => K, allowClosedSubstreamRecreation: Boolean): SubFlow[T, NotUsed, [+O]Source[O, NotUsed], RunnableGraph[NotUsed]]

    This operation demultiplexes the incoming stream into separate output streams, one for each element key.

    This operation demultiplexes the incoming stream into separate output streams, one for each element key. The key is computed for each element using the given function. When a new key is encountered for the first time a new substream is opened and subsequently fed with all elements belonging to that key.

    WARNING: If allowClosedSubstreamRecreation is set to false (default behavior) the operator keeps track of all keys of streams that have already been closed. If you expect an infinite number of keys this can cause memory issues. Elements belonging to those keys are drained directly and not send to the substream.

    Note: If allowClosedSubstreamRecreation is set to true substream completion and incoming elements are subject to race-conditions. If elements arrive for a stream that is in the process of closing these elements might get lost.

    The object returned from this method is not a normal Source or Flow, it is a SubFlow. This means that after this operator all transformations are applied to all encountered substreams in the same fashion. Substream mode is exited either by closing the substream (i.e. connecting it to a Sink) or by merging the substreams back together; see the to and mergeBack methods on SubFlow for more information.

    It is important to note that the substreams also propagate back-pressure as any other stream, which means that blocking one substream will block the groupBy operator itself—and thereby all substreams—once all internal or explicit buffers are filled.

    If the group by function f throws an exception and the supervision decision is akka.stream.Supervision.Stop the stream and substreams will be completed with failure.

    If the group by function f 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.

    Function f MUST NOT return null. This will throw exception and trigger supervision decision mechanism.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when an element for which the grouping function returns a group that has not yet been created. Emits the new group

    Backpressures when there is an element pending for a group whose substream backpressures

    Completes when upstream completes

    Cancels when downstream cancels and all substreams cancel

    maxSubstreams

    configures the maximum number of substreams (keys) that are supported; if more distinct keys are encountered then the stream fails

    f

    computes the key for each element

    allowClosedSubstreamRecreation

    enables recreation of already closed substreams if elements with their corresponding keys arrive after completion

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  64. def grouped(n: Int): Source[Seq[T], NotUsed]

    Chunk up this stream into groups of the given size, with the last group possibly smaller than requested due to end-of-stream.

    Chunk up this stream into groups of the given size, with the last group possibly smaller than requested due to end-of-stream.

    n must be positive, otherwise IllegalArgumentException is thrown.

    Emits when the specified number of elements have been accumulated or upstream completed

    Backpressures when a group has been assembled and downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  65. def groupedWeighted(minWeight: Long)(costFn: (T) => Long): Source[Seq[T], NotUsed]

    Chunk up this stream into groups of elements that have a cumulative weight greater than or equal to the minWeight, with the last group possibly smaller than requested minWeight due to end-of-stream.

    Chunk up this stream into groups of elements that have a cumulative weight greater than or equal to the minWeight, with the last group possibly smaller than requested minWeight due to end-of-stream.

    minWeight must be positive, otherwise IllegalArgumentException is thrown. costFn must return a non-negative result for all inputs, otherwise the stage will fail with an IllegalArgumentException.

    Emits when the cumulative weight of elements is greater than or equal to the minWeight or upstream completed

    Backpressures when a buffered group weighs more than minWeight and downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  66. def groupedWeightedWithin(maxWeight: Long, maxNumber: Int, d: FiniteDuration)(costFn: (T) => Long): Source[Seq[T], NotUsed]

    Chunk up this stream into groups of elements received within a time window, or limited by the weight and number of the elements, whatever happens first.

    Chunk up this stream into groups of elements received within a time window, or limited by the weight and number of the elements, whatever happens first. Empty groups will not be emitted if no elements are received from upstream. The last group before end-of-stream will contain the buffered elements since the previously emitted group.

    maxWeight must be positive, maxNumber must be positive, and d must be greater than 0 seconds, otherwise IllegalArgumentException is thrown.

    Emits when the configured time elapses since the last group has been emitted or weight limit reached

    Backpressures when downstream backpressures, and buffered group (+ pending element) weighs more than maxWeight or has more than maxNumber elements

    Completes when upstream completes (emits last group)

    Cancels when downstream completes

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  67. def groupedWeightedWithin(maxWeight: Long, d: FiniteDuration)(costFn: (T) => Long): Source[Seq[T], NotUsed]

    Chunk up this stream into groups of elements received within a time window, or limited by the weight of the elements, whatever happens first.

    Chunk up this stream into groups of elements received within a time window, or limited by the weight of the elements, whatever happens first. Empty groups will not be emitted if no elements are received from upstream. The last group before end-of-stream will contain the buffered elements since the previously emitted group.

    maxWeight must be positive, and d must be greater than 0 seconds, otherwise IllegalArgumentException is thrown.

    Emits when the configured time elapses since the last group has been emitted or weight limit reached

    Backpressures when downstream backpressures, and buffered group (+ pending element) weighs more than maxWeight

    Completes when upstream completes (emits last group)

    Cancels when downstream completes

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  68. def groupedWithin(n: Int, d: FiniteDuration): Source[Seq[T], NotUsed]

    Chunk up this stream into groups of elements received within a time window, or limited by the given number of elements, whatever happens first.

    Chunk up this stream into groups of elements received within a time window, or limited by the given number of elements, whatever happens first. Empty groups will not be emitted if no elements are received from upstream. The last group before end-of-stream will contain the buffered elements since the previously emitted group.

    n must be positive, and d must be greater than 0 seconds, otherwise IllegalArgumentException is thrown.

    Emits when the configured time elapses since the last group has been emitted or n elements is buffered

    Backpressures when downstream backpressures, and there are n+1 buffered elements

    Completes when upstream completes (emits last group)

    Cancels when downstream completes

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  69. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  70. def idleTimeout(timeout: FiniteDuration): Source[T, NotUsed]

    If the time between two processed elements exceeds the provided timeout, the stream is failed with a akka.stream.StreamIdleTimeoutException.

    If the time between two processed elements exceeds the provided timeout, the stream is failed with a akka.stream.StreamIdleTimeoutException. The timeout is checked periodically, so the resolution of the check is one period (equals to timeout value).

    Emits when upstream emits an element

    Backpressures when downstream backpressures

    Completes when upstream completes or fails if timeout elapses between two emitted elements

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  71. def initialDelay(delay: FiniteDuration): Source[T, NotUsed]

    Delays the initial element by the specified duration.

    Delays the initial element by the specified duration.

    Emits when upstream emits an element if the initial delay is already elapsed

    Backpressures when downstream backpressures or initial delay is not yet elapsed

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  72. def initialTimeout(timeout: FiniteDuration): Source[T, NotUsed]

    If the first element has not passed through this operator before the provided timeout, the stream is failed with a akka.stream.InitialTimeoutException.

    If the first element has not passed through this operator before the provided timeout, the stream is failed with a akka.stream.InitialTimeoutException.

    Emits when upstream emits an element

    Backpressures when downstream backpressures

    Completes when upstream completes or fails if timeout elapses before first element arrives

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  73. def interleave[U >: Out](that: Graph[SourceShape[U], _], segmentSize: Int, eagerClose: Boolean): Source[U, NotUsed]

    Interleave is a deterministic merge of the given Source with elements of this Flow.

    Interleave is a deterministic merge of the given Source with elements of this Flow. It first emits segmentSize number of elements from this flow to downstream, then - same amount for that source, then repeat process.

    If eagerClose is false and one of the upstreams complete the elements from the other upstream will continue passing through the interleave operator. If eagerClose is true and one of the upstream complete interleave will cancel the other upstream and complete itself.

    If it gets error from one of upstreams - stream completes with failure.

    Emits when element is available from the currently consumed upstream

    Backpressures when downstream backpressures. Signal to current upstream, switch to next upstream when received segmentSize elements

    Completes when the Flow and given Source completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  74. def interleave[U >: Out](that: Graph[SourceShape[U], _], segmentSize: Int): Source[U, NotUsed]

    Interleave is a deterministic merge of the given Source with elements of this Flow.

    Interleave is a deterministic merge of the given Source with elements of this Flow. It first emits segmentSize number of elements from this flow to downstream, then - same amount for that source, then repeat process.

    Example:

    Source(List(1, 2, 3)).interleave(List(4, 5, 6, 7), 2) // 1, 2, 4, 5, 3, 6, 7

    After one of upstreams is complete then all the rest elements will be emitted from the second one

    If it gets error from one of upstreams - stream completes with failure.

    Emits when element is available from the currently consumed upstream

    Backpressures when downstream backpressures. Signal to current upstream, switch to next upstream when received segmentSize elements

    Completes when the Flow and given Source completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  75. def interleaveAll[U >: Out](those: Seq[Graph[SourceShape[U], _]], segmentSize: Int, eagerClose: Boolean): Source[U, NotUsed]

    Interleave is a deterministic merge of the given Sources with elements of this Flow.

    Interleave is a deterministic merge of the given Sources with elements of this Flow. It first emits segmentSize number of elements from this flow to downstream, then - same amount for that source, then repeat process.

    If eagerClose is false and one of the upstreams complete the elements from the other upstream will continue passing through the interleave operator. If eagerClose is true and one of the upstream complete interleave will cancel the other upstream and complete itself.

    If it gets error from one of upstreams - stream completes with failure.

    Emits when element is available from the currently consumed upstream

    Backpressures when downstream backpressures. Signal to current upstream, switch to next upstream when received segmentSize elements

    Completes when the Flow and given Source completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  76. def interleaveMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2], segmentSize: Int, eagerClose: Boolean)(matF: (NotUsed, Mat2) => Mat3): Source[U, Mat3]

    Interleave is a deterministic merge of the given Source with elements of this Flow.

    Interleave is a deterministic merge of the given Source with elements of this Flow. It first emits segmentSize number of elements from this flow to downstream, then - same amount for that source, then repeat process.

    If eagerClose is false and one of the upstreams complete the elements from the other upstream will continue passing through the interleave operator. If eagerClose is true and one of the upstream complete interleave will cancel the other upstream and complete itself.

    If it gets error from one of upstreams - stream completes with failure.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    Annotations
    @nowarn()
    See also

    #interleave. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  77. def interleaveMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2], segmentSize: Int)(matF: (NotUsed, Mat2) => Mat3): Source[U, Mat3]

    Interleave is a deterministic merge of the given Source with elements of this Flow.

    Interleave is a deterministic merge of the given Source with elements of this Flow. It first emits segmentSize number of elements from this flow to downstream, then - same amount for that source, then repeat process.

    After one of upstreams is complete then all the rest elements will be emitted from the second one

    If it gets error from one of upstreams - stream completes with failure.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    Annotations
    @nowarn()
    See also

    #interleave. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  78. def intersperse[T >: Out](inject: T): Source[T, NotUsed]

    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.

    Additionally can inject start and end marker elements to stream.

    Examples:

    val nums = Source(List(1,2,3)).map(_.toString)
nums.intersperse(",")            //   1 , 2 , 3
nums.intersperse("[", ",", "]")  // [ 1 , 2 , 3 ]

    Emits when upstream emits (or before with the start element if provided)

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  79. def intersperse[T >: Out](start: T, inject: T, end: T): Source[T, NotUsed]

    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.

    Additionally can inject start and end marker elements to stream.

    Examples:

    val nums = Source(List(1,2,3)).map(_.toString)
nums.intersperse(",")            //   1 , 2 , 3
nums.intersperse("[", ",", "]")  // [ 1 , 2 , 3 ]

    In case you want to only prepend or only append an element (yet still use the intercept feature to inject a separator between elements, you may want to use the following pattern instead of the 3-argument version of intersperse (See Source.concat for semantics details):

    Source.single(">> ") ++ Source(List("1", "2", "3")).intersperse(",")
Source(List("1", "2", "3")).intersperse(",") ++ Source.single("END")

    Emits when upstream emits (or before with the start element if provided)

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  80. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  81. def keepAlive[U >: Out](maxIdle: FiniteDuration, injectedElem: () => U): Source[U, NotUsed]

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

    Injects additional elements if upstream does not emit for a configured amount of time. In other words, this operator attempts to maintains a base rate of emitted elements towards the downstream.

    If the downstream backpressures then no element is injected until downstream demand arrives. Injected elements do not accumulate during this period.

    Upstream elements are always preferred over injected elements.

    Emits when upstream emits an element or if the upstream was idle for the configured period

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  82. def limit(max: Long): Source[T, NotUsed]

    Ensure stream boundedness by limiting the number of elements from upstream.

    Ensure stream boundedness by limiting the number of elements from upstream. If the number of incoming elements exceeds max, it will signal upstream failure StreamLimitException downstream.

    Due to input buffering some elements may have been requested from upstream publishers that will then not be processed downstream of this step.

    Emits when upstream emits and the number of emitted elements has not reached max

    Backpressures when downstream backpressures

    Completes when upstream completes and the number of emitted elements has not reached max

    Errors when the total number of incoming element exceeds max

    Cancels when downstream cancels

    See also FlowOps.take, FlowOps.takeWithin, FlowOps.takeWhile

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  83. def limitWeighted[T](max: Long)(costFn: (T) => Long): Source[T, NotUsed]

    Ensure stream boundedness by evaluating the cost of incoming elements using a cost function.

    Ensure stream boundedness by evaluating the cost of incoming elements using a cost function. Exactly how many elements will be allowed to travel downstream depends on the evaluated cost of each element. If the accumulated cost exceeds max, it will signal upstream failure StreamLimitException downstream.

    Due to input buffering some elements may have been requested from upstream publishers that will then not be processed downstream of this step.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when upstream emits and the accumulated cost has not reached max

    Backpressures when downstream backpressures

    Completes when upstream completes and the number of emitted elements has not reached max

    Errors when when the accumulated cost exceeds max

    Cancels when downstream cancels

    See also FlowOps.take, FlowOps.takeWithin, FlowOps.takeWhile

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  84. def log(name: String, extract: (T) => Any = ConstantFun.scalaIdentityFunction)(implicit log: LoggingAdapter = null): Source[T, NotUsed]

    Logs elements flowing through the stream as well as completion and erroring.

    Logs elements flowing through the stream as well as completion and erroring.

    By default element and completion signals are logged on debug level, and errors are logged on Error level. This can be adjusted according to your needs by providing a custom Attributes.LogLevels attribute on the given Flow:

    Uses implicit LoggingAdapter if available, otherwise uses an internally created one, which uses akka.event.Logging(materializer.system, materializer) as its source (use this class to configure slf4j loggers).

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the mapping function returns an element

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  85. def logWithMarker(name: String, marker: (T) => LogMarker, extract: (T) => Any = ConstantFun.scalaIdentityFunction)(implicit log: MarkerLoggingAdapter = null): Source[T, NotUsed]

    Logs elements flowing through the stream as well as completion and erroring.

    Logs elements flowing through the stream as well as completion and erroring.

    By default element and completion signals are logged on debug level, and errors are logged on Error level. This can be adjusted according to your needs by providing a custom Attributes.LogLevels attribute on the given Flow:

    Uses implicit MarkerLoggingAdapter if available, otherwise uses an internally created one, which uses akka.event.Logging.withMarker(materializer.system, materializer) as its source (use this class to configure slf4j loggers).

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the mapping function returns an element

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  86. def map[T](f: (T) => T): Source[T, NotUsed]

    Transform this stream by applying the given function to each of the elements as they pass through this processing step.

    Transform this stream by applying the given function to each of the elements as they pass through this processing step.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the mapping function returns an element

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  87. def mapAsync[T](parallelism: Int)(f: (T) => Future[T]): Source[T, NotUsed]

    Transform this stream by applying the given function to each of the elements as they pass through this processing step.

    Transform this stream by applying the given function to each of the elements as they pass through this processing step. The function returns a Future and the value of that future will be emitted downstream. The number of Futures that shall run in parallel is given as the first argument to mapAsync. These Futures may complete in any order, but the elements that are emitted downstream are in the same order as received from upstream.

    If the function f throws an exception or if the Future is completed with failure and the supervision decision is akka.stream.Supervision.Stop the stream will be completed with failure.

    If the function f throws an exception or if the Future is completed with failure and the supervision decision is akka.stream.Supervision.Resume or akka.stream.Supervision.Restart the element is dropped and the stream continues.

    If the Future is completed with null, it is ignored and the next element is processed.

    The function f is always invoked on the elements in the order they arrive.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the Future returned by the provided function finishes for the next element in sequence

    Backpressures when the number of futures reaches the configured parallelism and the downstream backpressures or the first future is not completed

    Completes when upstream completes and all futures have been completed and all elements have been emitted

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    See also

    #mapAsyncUnordered and #mapAsyncPartitioned

  88. def mapAsyncPartitioned[T, P](parallelism: Int, perPartition: Int)(partitioner: (T) => P)(f: (T, P) => Future[T]): Source[T, NotUsed]

    Transform this stream by partitioning elements based on the provided partitioner as they pass through this step and then applying a given Future-returning function to each element and its partition key.

    Transform this stream by partitioning elements based on the provided partitioner as they pass through this step and then applying a given Future-returning function to each element and its partition key. The value of the returned future, if successful, will be emitted downstream.

    The number of Futures running at any given time is bounded by the 'parallelism' and 'perPartition' values. The futures may complete in any order, but the results are emitted in the same order as the corresponding elements were received.

    If the functions 'partitioner' or 'f' throw an exception, or the Future completes with failure, supervision will be applied to determine a decision. If the decision is akka.stream.Supervision.Stop the stream will be stopped with failure; otherwise, the element will be dropped and the stream continues.

    The function 'partitioner' is always invoked on the elements in the order they arrive.

    The function 'f' is invoked on elements with the same partition key in the order they arrive. The order of invocation of 'f' for elements with different partition keys is undefined and subject to factors including, but not limited to, the distribution of partition keys within the stream.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the Future returned by 'f' finishes for the next element in sequence

    Backpressures when the number of elements for which no resulting future has completed reaches the configured parallelism and the downstream backpressures

    Completes when upstream completes and all futures have been completed and all results have been emitted

    Cancels when downstream cancels

    parallelism

    at most this many futures will be incomplete at any time

    perPartition

    at most this many futures will be incomplete for a given partition key at any time

    partitioner

    function to generate a partition key

    f

    function to generate a Future

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    See also

    #mapAsync and #mapAsyncUnordered

  89. def mapAsyncUnordered[T](parallelism: Int)(f: (T) => Future[T]): Source[T, NotUsed]

    Transform this stream by applying the given function to each of the elements as they pass through this processing step.

    Transform this stream by applying the given function to each of the elements as they pass through this processing step. The function returns a Future and the value of that future will be emitted downstream. The number of Futures that shall run in parallel is given as the first argument to mapAsyncUnordered. Each processed element will be emitted downstream as soon as it is ready, i.e. it is possible that the elements are not emitted downstream in the same order as received from upstream.

    If the function f throws an exception or if the Future is completed with failure and the supervision decision is akka.stream.Supervision.Stop the stream will be completed with failure.

    If the function f throws an exception or if the Future is completed with failure and the supervision decision is akka.stream.Supervision.Resume or akka.stream.Supervision.Restart the element is dropped and the stream continues.

    If the Future is completed with null, it is ignored and the next element is processed.

    The function f is always invoked on the elements in the order they arrive (even though the result of the futures returned by f might be emitted in a different order).

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when any of the Futures returned by the provided function complete

    Backpressures when the number of futures reaches the configured parallelism and the downstream backpressures

    Completes when upstream completes and all futures have been completed and all elements have been emitted

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    See also

    #mapAsync and #mapAsyncPartitioned

  90. def mapConcat[T](f: (T) => IterableOnce[T]): Source[T, NotUsed]

    Transform each input element into an Iterable of output elements that is then flattened into the output stream.

    Transform each input element into an Iterable of output elements that is then flattened into the output stream.

    The returned Iterable MUST NOT contain null values, as they are illegal as stream elements - according to the Reactive Streams specification.

    Emits when the mapping function returns an element or there are still remaining elements from the previously calculated collection

    Backpressures when downstream backpressures or there are still remaining elements from the previously calculated collection

    Completes when upstream completes and all remaining elements have been emitted

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  91. def mapError(pf: PartialFunction[Throwable, Throwable]): Source[T, NotUsed]

    While similar to recover this operator can be used to transform an error signal to a different one *without* logging it as an error in the process.

    While similar to recover this operator can be used to transform an error signal to a different one *without* logging it as an error in the process. So in that sense it is NOT exactly equivalent to recover(t => throw t2) since recover would log the t2 error.

    Since the underlying failure signal onError arrives out-of-band, it might jump over existing elements. This operator can recover the failure signal, but not the skipped elements, which will be dropped.

    Similarly to recover throwing an exception inside mapError _will_ be logged.

    Emits when element is available from the upstream or upstream is failed and pf returns an element

    Backpressures when downstream backpressures

    Completes when upstream completes or upstream failed with exception pf can handle

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  92. def mapMaterializedValue[Mat2](f: (NotUsed) => Mat2): Source[T, Mat2]

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

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

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → FlowOpsMat
  93. def mapWithResource[R, T](create: () => R)(f: (R, T) => T, close: (R) => Option[T]): Source[T, NotUsed]

    Transform each stream element with the help of a resource.

    Transform each stream element with the help of a resource.

    The resource creation function is invoked once when the stream is materialized and the returned resource is passed to the mapping function for mapping the first element. The mapping function returns a mapped element to emit downstream. The returned T MUST NOT be null as it is illegal as stream element - according to the Reactive Streams specification.

    The close function is called only once when the upstream or downstream finishes or fails. You can do some clean-up here, and if the returned value is not empty, it will be emitted to the downstream if available, otherwise the value will be dropped.

    Early completion can be done with combination of the takeWhile operator.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    You can configure the default dispatcher for this Source by changing the akka.stream.materializer.blocking-io-dispatcher or set it for a given Source by using ActorAttributes.

    Emits when the mapping function returns an element and downstream is ready to consume it

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    R

    the type of the resource

    T

    the type of the output elements

    create

    function that creates the resource

    f

    function that transforms the upstream element and the resource to output element

    close

    function that closes the resource, optionally outputting a last element

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  94. def merge[U >: Out, M](that: Graph[SourceShape[U], M], eagerComplete: Boolean = false): Source[U, NotUsed]

    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 (eagerComplete=false) or one upstream completes (eagerComplete=true), default value is false

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  95. def mergeAll[U >: Out](those: Seq[Graph[SourceShape[U], _]], eagerComplete: Boolean): Source[U, NotUsed]

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

    Merge the given Sources 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 (eagerComplete=false) or one upstream completes (eagerComplete=true), default value is false

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  96. def mergeLatest[U >: Out, M](that: Graph[SourceShape[U], M], eagerComplete: Boolean = false): Source[Seq[U], NotUsed]

    MergeLatest joins elements from N input streams into stream of lists of size N.

    MergeLatest joins elements from N input streams into stream of lists of size N. i-th element in list is the latest emitted element from i-th input stream. MergeLatest emits list for each element emitted from some input stream, but only after each input stream emitted at least one element.

    Emits when an element is available from some input and each input emits at least one element from stream start

    Completes when all upstreams complete (eagerClose=false) or one upstream completes (eagerClose=true)

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  97. def mergeLatestMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2], eagerClose: Boolean)(matF: (NotUsed, Mat2) => Mat3): Source[Seq[U], Mat3]

    MergeLatest joins elements from N input streams into stream of lists of size N.

    MergeLatest joins elements from N input streams into stream of lists of size N. i-th element in list is the latest emitted element from i-th input stream. MergeLatest emits list for each element emitted from some input stream, but only after each input stream emitted at least one element.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #mergeLatest. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  98. def mergeMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2], eagerComplete: Boolean = false)(matF: (NotUsed, Mat2) => Mat3): Source[U, Mat3]

    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.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #merge. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  99. def mergePreferred[U >: Out, M](that: Graph[SourceShape[U], M], preferred: Boolean, eagerComplete: Boolean = false): Source[U, NotUsed]

    Merge two sources.

    Merge two sources. Prefer one source if both sources have elements ready.

    emits when one of the inputs has an element available. If multiple have elements available, prefer the 'right' one when 'preferred' is 'true', or the 'left' one when 'preferred' is 'false'.

    backpressures when downstream backpressures

    completes when all upstreams complete (This behavior is changeable to completing when any upstream completes by setting eagerComplete=true.)

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    Annotations
    @nowarn()
  100. def mergePreferredMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2], preferred: Boolean, eagerClose: Boolean)(matF: (NotUsed, Mat2) => Mat3): Source[U, Mat3]

    Merge two sources.

    Merge two sources. Prefer one source if both sources have elements ready.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #mergePreferred It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  101. def mergePrioritized[U >: Out, M](that: Graph[SourceShape[U], M], leftPriority: Int, rightPriority: Int, eagerComplete: Boolean = false): Source[U, NotUsed]

    Merge two sources.

    Merge two sources. Prefer the sources depending on the 'priority' parameters.

    emits when one of the inputs has an element available, preferring inputs based on the 'priority' parameters if both have elements available

    backpressures when downstream backpressures

    completes when both upstreams complete (This behavior is changeable to completing when any upstream completes by setting eagerComplete=true.)

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  102. def mergePrioritizedMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2], leftPriority: Int, rightPriority: Int, eagerClose: Boolean)(matF: (NotUsed, Mat2) => Mat3): Source[U, Mat3]

    Merge two sources.

    Merge two sources. Prefer the sources depending on the 'priority' parameters.

    It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
  103. def mergeSorted[U >: Out, M](that: Graph[SourceShape[U], M])(implicit ord: Ordering[U]): Source[U, NotUsed]

    Merge the given Source to this Flow, taking elements as they arrive from input streams, picking always the smallest of the available elements (waiting for one element from each side to be available).

    Merge the given Source to this Flow, taking elements as they arrive from input streams, picking always the smallest of the available elements (waiting for one element from each side to be available). This means that possible contiguity of the input streams is not exploited to avoid waiting for elements, this merge will block when one of the inputs does not have more elements (and does not complete).

    Emits when all of the inputs have an element available

    Backpressures when downstream backpressures

    Completes when all upstreams complete

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  104. def mergeSortedMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2])(matF: (NotUsed, Mat2) => Mat3)(implicit ord: Ordering[U]): Source[U, Mat3]

    Merge the given Source to this Flow, taking elements as they arrive from input streams, picking always the smallest of the available elements (waiting for one element from each side to be available).

    Merge the given Source to this Flow, taking elements as they arrive from input streams, picking always the smallest of the available elements (waiting for one element from each side to be available). This means that possible contiguity of the input streams is not exploited to avoid waiting for elements, this merge will block when one of the inputs does not have more elements (and does not complete).

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #mergeSorted. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  105. def monitor: Source[T, (NotUsed, FlowMonitor[T])]

    Materializes to (Mat, FlowMonitor[Out]), which is unlike most other operators (!), in which usually the default materialized value keeping semantics is to keep the left value (by passing Keep.left() to a *Mat version of a method).

    Materializes to (Mat, FlowMonitor[Out]), which is unlike most other operators (!), in which usually the default materialized value keeping semantics is to keep the left value (by passing Keep.left() to a *Mat version of a method). This operator is an exception from that rule and keeps both values since dropping its sole purpose is to introduce that materialized value.

    The FlowMonitor[Out] allows monitoring of the current flow. All events are propagated by the monitor unchanged. Note that the monitor inserts a memory barrier every time it processes an event, and may therefor affect performance.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
  106. def monitorMat[Mat2](combine: (NotUsed, FlowMonitor[T]) => Mat2): Source[T, Mat2]

    Materializes to FlowMonitor[Out] that allows monitoring of the current flow.

    Materializes to FlowMonitor[Out] that allows monitoring of the current flow. All events are propagated by the monitor unchanged. Note that the monitor inserts a memory barrier every time it processes an event, and may therefor affect performance.

    The combine function is used to combine the FlowMonitor with this flow's materialized value.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
  107. def named(name: String): Source[T, NotUsed]

    Add a name attribute to this Source.

    Add a name attribute to this Source.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → Graph → FlowOps
  108. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  109. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  110. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @HotSpotIntrinsicCandidate() @native()
  111. def onErrorComplete(pf: PartialFunction[Throwable, Boolean]): Source[T, NotUsed]

    onErrorComplete allows to complete the stream when an upstream error occurs.

    onErrorComplete allows to complete the stream when an upstream error occurs.

    Since the underlying failure signal onError arrives out-of-band, it might jump over existing elements. This operator can recover the failure signal, but not the skipped elements, which will be dropped.

    Emits when element is available from the upstream

    Backpressures when downstream backpressures

    Completes when upstream completes or failed with exception pf can handle

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  112. def onErrorComplete[T <: Throwable]()(implicit tag: ClassTag[T]): Source[T, NotUsed]

    onErrorComplete allows to complete the stream when an upstream error occurs.

    onErrorComplete allows to complete the stream when an upstream error occurs.

    Since the underlying failure signal onError arrives out-of-band, it might jump over existing elements. This operator can recover the failure signal, but not the skipped elements, which will be dropped.

    Emits when element is available from the upstream

    Backpressures when downstream backpressures

    Completes when upstream completes or failed with exception is an instance of the provided type

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  113. def orElse[U >: Out, Mat2](secondary: Graph[SourceShape[U], Mat2]): Source[U, NotUsed]

    Provides a secondary source that will be consumed if this stream completes without any elements passing by.

    Provides a secondary source that will be consumed if this stream completes without any elements passing by. As soon as the first element comes through this stream, the alternative will be cancelled.

    Note that this Flow will be materialized together with the Source and just kept from producing elements by asserting back-pressure until its time comes or it gets cancelled.

    On errors the operator is failed regardless of source of the error.

    Emits when element is available from first stream or first stream closed without emitting any elements and an element is available from the second stream

    Backpressures when downstream backpressures

    Completes when the primary stream completes after emitting at least one element, when the primary stream completes without emitting and the secondary stream already has completed or when the secondary stream completes

    Cancels when downstream cancels and additionally the alternative is cancelled as soon as an element passes by from this stream.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  114. def orElseMat[U >: Out, Mat2, Mat3](secondary: Graph[SourceShape[U], Mat2])(matF: (NotUsed, Mat2) => Mat3): Source[U, Mat3]

    Provides a secondary source that will be consumed if this stream completes without any elements passing by.

    Provides a secondary source that will be consumed if this stream completes without any elements passing by. As soon as the first element comes through this stream, the alternative will be cancelled.

    Note that this Flow will be materialized together with the Source and just kept from producing elements by asserting back-pressure until its time comes or it gets cancelled.

    On errors the operator is failed regardless of source of the error.

    Emits when element is available from first stream or first stream closed without emitting any elements and an element is available from the second stream

    Backpressures when downstream backpressures

    Completes when the primary stream completes after emitting at least one element, when the primary stream completes without emitting and the secondary stream already has completed or when the secondary stream completes

    Cancels when downstream cancels and additionally the alternative is cancelled as soon as an element passes by from this stream.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
  115. def preMaterialize()(implicit materializer: Materializer): (NotUsed, Source[T, NotUsed])

    Materializes this Source, immediately returning (1) its materialized value, and (2) a new Source that can be used to consume elements from the newly materialized Source.

    Materializes this Source, immediately returning (1) its materialized value, and (2) a new Source that can be used to consume elements from the newly materialized Source.

    Note that preMaterialize is implemented through a reactive streams Publisher which means that a buffer is introduced and that errors are not propagated upstream but are turned into cancellations without error details.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source
  116. def prefixAndTail[U >: Out](n: Int): Source[(Seq[T], Source[U, NotUsed]), NotUsed]

    Takes up to n elements from the stream (less than n only if the upstream completes before emitting n elements) and returns a pair containing a strict sequence of the taken element and a stream representing the remaining elements.

    Takes up to n elements from the stream (less than n only if the upstream completes before emitting n elements) and returns a pair containing a strict sequence of the taken element and a stream representing the remaining elements. If n is zero or negative, then this will return a pair of an empty collection and a stream containing the whole upstream unchanged.

    In case of an upstream error, depending on the current state

    • the master stream signals the error if less than n elements has been seen, and therefore the substream has not yet been emitted
    • the tail substream signals the error after the prefix and tail has been emitted by the main stream (at that point the main stream has already completed)

    Emits when the configured number of prefix elements are available. Emits this prefix, and the rest as a substream

    Backpressures when downstream backpressures or substream backpressures

    Completes when prefix elements have been consumed and substream has been consumed

    Cancels when downstream cancels or substream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  117. def prepend[U >: Out, Mat2](that: Graph[SourceShape[U], Mat2]): Source[U, NotUsed]

    Prepend the given Source to this Flow, meaning that before elements are generated from this Flow, the Source's elements will be produced until it is exhausted, at which point Flow elements will start being produced.

    Prepend the given Source to this Flow, meaning that before elements are generated from this Flow, the Source's elements will be produced until it is exhausted, at which point Flow elements will start being produced.

    Note that the Source is materialized together with this Flow and is "detached" meaning in effect behave as a one element buffer in front of both the sources, that eagerly demands an element on start (so it can not be combined with Source.lazy to defer materialization of that).

    This flow will then be kept from producing elements by asserting back-pressure until its time comes.

    When needing a prepend operator that is not detached use #prependLazy

    Emits when element is available from the given Source or from current stream when the Source is completed

    Backpressures when downstream backpressures

    Completes when this Flow completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  118. def prependLazy[U >: Out, Mat2](that: Graph[SourceShape[U], Mat2]): Source[U, NotUsed]

    Prepend the given Source to this Flow, meaning that before elements are generated from this Flow, the Source's elements will be produced until it is exhausted, at which point Flow elements will start being produced.

    Prepend the given Source to this Flow, meaning that before elements are generated from this Flow, the Source's elements will be produced until it is exhausted, at which point Flow elements will start being produced.

    Note that the Source is materialized together with this Flow and will then be kept from producing elements by asserting back-pressure until its time comes.

    When needing a prepend operator that is also detached use #prepend

    If the given Source gets upstream error - no elements from this Flow will be pulled.

    Emits when element is available from the given Source or from current stream when the Source is completed

    Backpressures when downstream backpressures

    Completes when this Flow completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  119. def prependLazyMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2])(matF: (NotUsed, Mat2) => Mat3): Source[U, Mat3]

    Prepend the given Source to this Flow, meaning that before elements are generated from this Flow, the Source's elements will be produced until it is exhausted, at which point Flow elements will start being produced.

    Prepend the given Source to this Flow, meaning that before elements are generated from this Flow, the Source's elements will be produced until it is exhausted, at which point Flow elements will start being produced.

    Note that the Source is materialized together with this Flow and is "detached" meaning in effect behave as a one element buffer in front of both the sources, that eagerly demands an element on start (so it can not be combined with Source.lazy to defer materialization of that).

    This flow will then be kept from producing elements by asserting back-pressure until its time comes.

    When needing a prepend operator that is not detached use #prependLazyMat

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #prependLazy. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  120. def prependMat[U >: Out, Mat2, Mat3](that: Graph[SourceShape[U], Mat2])(matF: (NotUsed, Mat2) => Mat3): Source[U, Mat3]

    Prepend the given Source to this Flow, meaning that before elements are generated from this Flow, the Source's elements will be produced until it is exhausted, at which point Flow elements will start being produced.

    Prepend the given Source to this Flow, meaning that before elements are generated from this Flow, the Source's elements will be produced until it is exhausted, at which point Flow elements will start being produced.

    Note that this Flow will be materialized together with the Source and just kept from producing elements by asserting back-pressure until its time comes.

    If the given Source gets upstream error - no elements from this Flow will be pulled.

    When needing a concat operator that is not detached use #prependLazyMat

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #prepend. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  121. def recover[T >: Out](pf: PartialFunction[Throwable, T]): Source[T, NotUsed]

    Recover allows to send last element on failure and gracefully complete the stream Since the underlying failure signal onError arrives out-of-band, it might jump over existing elements.

    Recover allows to send last element on failure and gracefully complete the stream Since the underlying failure signal onError arrives out-of-band, it might jump over existing elements. This operator can recover the failure signal, but not the skipped elements, which will be dropped.

    Throwing an exception inside recover _will_ be logged on ERROR level automatically.

    Emits when element is available from the upstream or upstream is failed and pf returns an element

    Backpressures when downstream backpressures

    Completes when upstream completes or upstream failed with exception pf can handle

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  122. def recoverWith[T >: Out](pf: PartialFunction[Throwable, Graph[SourceShape[T], NotUsed]]): Source[T, NotUsed]

    RecoverWith allows to switch to alternative Source on flow failure.

    RecoverWith allows to switch to alternative Source on flow failure. It will stay in effect after a failure has been recovered so that each time there is a failure it is fed into the pf and a new Source may be materialized.

    Since the underlying failure signal onError arrives out-of-band, it might jump over existing elements. This operator can recover the failure signal, but not the skipped elements, which will be dropped.

    Throwing an exception inside recoverWith _will_ be logged on ERROR level automatically.

    Emits when element is available from the upstream or upstream is failed and element is available from alternative Source

    Backpressures when downstream backpressures

    Completes when upstream completes or upstream failed with exception pf can handle

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  123. def recoverWithRetries[T >: Out](attempts: Int, pf: PartialFunction[Throwable, Graph[SourceShape[T], NotUsed]]): Source[T, NotUsed]

    RecoverWithRetries allows to switch to alternative Source on flow failure.

    RecoverWithRetries allows to switch to alternative Source on flow failure. It will stay in effect after a failure has been recovered up to attempts number of times so that each time there is a failure it is fed into the pf and a new Source may be materialized. Note that if you pass in 0, this won't attempt to recover at all.

    A negative attempts number is interpreted as "infinite", which results in the exact same behavior as recoverWith.

    Since the underlying failure signal onError arrives out-of-band, it might jump over existing elements. This operator can recover the failure signal, but not the skipped elements, which will be dropped.

    Throwing an exception inside recoverWithRetries _will_ be logged on ERROR level automatically.

    Emits when element is available from the upstream or upstream is failed and element is available from alternative Source

    Backpressures when downstream backpressures

    Completes when upstream completes or upstream failed with exception pf can handle

    Cancels when downstream cancels

    attempts

    Maximum number of retries or -1 to retry indefinitely

    pf

    Receives the failure cause and returns the new Source to be materialized if any

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  124. def reduce[T >: Out](f: (T, T) => T): Source[T, NotUsed]

    Similar to fold but uses first element as zero element.

    Similar to fold but uses first element as zero element. Applies the given function towards its current and next value, yielding the next current value.

    If the stream is empty (i.e. completes before signalling any elements), the reduce operator will fail its downstream with a NoSuchElementException, which is semantically in-line with that Scala's standard library collections do in such situations.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when upstream completes

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    See also FlowOps.fold

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  125. def run()(implicit materializer: Materializer): Future[Done]

    Connect this Source to the Sink.ignore and run it.

    Connect this Source to the Sink.ignore and run it. Elements from the stream will be consumed and discarded.

    Note that the ActorSystem can be used as the implicit materializer parameter to use the akka.stream.SystemMaterializer for running the stream.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source
  126. def runFold[U](zero: U)(f: (U, T) => U)(implicit materializer: Materializer): Future[U]

    Shortcut for running this Source with a fold function.

    Shortcut for running this Source with a fold function. The given function is invoked for every received element, giving it its previous output (or the given zero value) and the element as input. The returned scala.concurrent.Future will be completed with value of the final function evaluation when the input stream ends, or completed with Failure if there is a failure signaled in the stream.

    Note that the ActorSystem can be used as the implicit materializer parameter to use the akka.stream.SystemMaterializer for running the stream.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source
  127. def runFoldAsync[U](zero: U)(f: (U, T) => Future[U])(implicit materializer: Materializer): Future[U]

    Shortcut for running this Source with a foldAsync function.

    Shortcut for running this Source with a foldAsync function. The given function is invoked for every received element, giving it its previous output (or the given zero value) and the element as input. The returned scala.concurrent.Future will be completed with value of the final function evaluation when the input stream ends, or completed with Failure if there is a failure signaled in the stream.

    Note that the ActorSystem can be used as the implicit materializer parameter to use the akka.stream.SystemMaterializer for running the stream.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source
  128. def runForeach(f: (T) => Unit)(implicit materializer: Materializer): Future[Done]

    Shortcut for running this Source with a foreach procedure.

    Shortcut for running this Source with a foreach procedure. The given procedure is invoked for each received element. The returned scala.concurrent.Future will be completed with Success when reaching the normal end of the stream, or completed with Failure if there is a failure signaled in the stream.

    Note that the ActorSystem can be used as the implicit materializer parameter to use the akka.stream.SystemMaterializer for running the stream.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source
  129. def runReduce[U >: Out](f: (U, U) => U)(implicit materializer: Materializer): Future[U]

    Shortcut for running this Source with a reduce function.

    Shortcut for running this Source with a reduce function. The given function is invoked for every received element, giving it its previous output (from the second element) and the element as input. The returned scala.concurrent.Future will be completed with value of the final function evaluation when the input stream ends, or completed with Failure if there is a failure signaled in the stream.

    If the stream is empty (i.e. completes before signalling any elements), the reduce operator will fail its downstream with a NoSuchElementException, which is semantically in-line with that Scala's standard library collections do in such situations.

    Note that the ActorSystem can be used as the implicit materializer parameter to use the akka.stream.SystemMaterializer for running the stream.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source
  130. def runWith[Mat2](sink: Graph[SinkShape[T], Mat2])(implicit materializer: Materializer): Mat2

    Connect this Source to a Sink and run it.

    Connect this Source to a Sink and run it. The returned value is the materialized value of the Sink, e.g. the Publisher of a akka.stream.scaladsl.Sink#publisher.

    Note that the ActorSystem can be used as the implicit materializer parameter to use the akka.stream.SystemMaterializer for running the stream.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source
  131. def scan[T](zero: T)(f: (T, T) => T): Source[T, NotUsed]

    Similar to fold but is not a terminal operation, emits its current value which starts at zero and then applies the current and next value to the given function f, emitting the next current value.

    Similar to fold but is not a terminal operation, emits its current value which starts at zero and then applies the current and next value to the given function f, emitting 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.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Note that the zero value must be immutable.

    Emits when the function scanning the element returns a new element

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    See also FlowOps.scanAsync

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  132. def scanAsync[T](zero: T)(f: (T, T) => Future[T]): Source[T, NotUsed]

    Similar to scan but with an asynchronous function, emits its current value which starts at zero and then applies the current and next value to the given function f, emitting a Future that resolves to the next current value.

    Similar to scan but with an asynchronous function, emits its current value which starts at zero and then applies the current and next value to the given function f, emitting a Future that resolves to 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.

    If the function f throws an exception and the supervision decision is akka.stream.Supervision.Resume current value starts at the previous current value, or zero when it doesn't have one, and the stream will continue.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Note that the zero value must be immutable.

    Emits when the future returned by f completes

    Backpressures when downstream backpressures

    Completes when upstream completes and the last future returned by f completes

    Cancels when downstream cancels

    See also FlowOps.scan

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  133. val shape: SourceShape[T]

    The shape of a graph is all that is externally visible: its inlets and outlets.

    The shape of a graph is all that is externally visible: its inlets and outlets.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → Graph
  134. def sliding(n: Int, step: Int = 1): Source[Seq[T], NotUsed]

    Apply a sliding window over the stream and return the windows as groups of elements, with the last group possibly smaller than requested due to end-of-stream.

    Apply a sliding window over the stream and return the windows as groups of elements, with the last group possibly smaller than requested due to end-of-stream.

    n must be positive, otherwise IllegalArgumentException is thrown. step must be positive, otherwise IllegalArgumentException is thrown.

    Emits when enough elements have been collected within the window or upstream completed

    Backpressures when a window has been assembled and downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  135. def splitAfter(p: (T) => Boolean): SubFlow[T, NotUsed, [+O]Source[O, NotUsed], RunnableGraph[NotUsed]]

    This operation applies the given predicate to all incoming elements and emits them to a stream of output streams.

    This operation applies the given predicate to all incoming elements and emits them to a stream of output streams. It *ends* the current substream when the predicate is true.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    See also

    #splitAfter

  136. def splitAfter(substreamCancelStrategy: SubstreamCancelStrategy)(p: (T) => Boolean): SubFlow[T, NotUsed, [+O]Source[O, NotUsed], RunnableGraph[NotUsed]]

    This operation applies the given predicate to all incoming elements and emits them to a stream of output streams.

    This operation applies the given predicate to all incoming elements and emits them to a stream of output streams. It *ends* the current substream when the predicate is true. This means that for the following series of predicate values, three substreams will be produced with lengths 2, 2, and 3:

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

    The object returned from this method is not a normal Source or Flow, it is a SubFlow. This means that after this operator all transformations are applied to all encountered substreams in the same fashion. Substream mode is exited either by closing the substream (i.e. connecting it to a Sink) or by merging the substreams back together; see the to and mergeBack methods on SubFlow for more information.

    It is important to note that the substreams also propagate back-pressure as any other stream, which means that blocking one substream will block the splitAfter operator itself—and thereby all substreams—once all internal or explicit buffers are filled.

    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.

    Emits when an element passes through. When the provided predicate is true it emits the element and opens 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 on SubstreamCancelStrategy.drain, downstream cancels or any substream cancels on SubstreamCancelStrategy.propagate

    See also FlowOps.splitWhen.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  137. def splitWhen(p: (T) => Boolean): SubFlow[T, NotUsed, [+O]Source[O, NotUsed], RunnableGraph[NotUsed]]

    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.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
    See also

    #splitWhen

  138. def splitWhen(substreamCancelStrategy: SubstreamCancelStrategy)(p: (T) => Boolean): SubFlow[T, NotUsed, [+O]Source[O, NotUsed], RunnableGraph[NotUsed]]

    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

    The object returned from this method is not a normal Source or Flow, it is a SubFlow. This means that after this operator all transformations are applied to all encountered substreams in the same fashion. Substream mode is exited either by closing the substream (i.e. connecting it to a Sink) or by merging the substreams back together; see the to and mergeBack methods on SubFlow for more information.

    It is important to note that the substreams also propagate back-pressure as any other stream, which means that blocking one substream will block the splitWhen operator itself—and thereby all substreams—once all internal or explicit buffers are filled.

    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.

    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 on SubstreamCancelStrategy.drain, downstream cancels or any substream cancels on SubstreamCancelStrategy.propagate

    See also FlowOps.splitAfter.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  139. def statefulMap[S, T](create: () => S)(f: (S, T) => (S, T), onComplete: (S) => Option[T]): Source[T, NotUsed]

    Transform each stream element with the help of a state.

    Transform each stream element with the help of a state.

    The state creation function is invoked once when the stream is materialized and the returned state is passed to the mapping function for mapping the first element. The mapping function returns a mapped element to emit downstream and a state to pass to the next mapping function. The state can be the same for each mapping return, be a new immutable state but it is also safe to use a mutable state. The returned T MUST NOT be null as it is illegal as stream element - according to the Reactive Streams specification. A null state is not allowed and will fail the stream.

    For stateless variant see FlowOps.map.

    The onComplete function is called only once when the upstream or downstream finished, You can do some clean-up here, and if the returned value is not empty, it will be emitted to the downstream if available, otherwise the value will be dropped.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the mapping function returns an element and downstream is ready to consume it

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    S

    the type of the state

    T

    the type of the output elements

    create

    a function that creates the initial state

    f

    a function that transforms the upstream element and the state into a pair of next state and output element

    onComplete

    a function that transforms the ongoing state into an optional output element

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  140. def statefulMapConcat[T](f: () => (T) => IterableOnce[T]): Source[T, NotUsed]

    Transform each input element into an Iterable of output elements that is then flattened into the output stream.

    Transform each input element into an Iterable of output elements that is then flattened into the output stream. The transformation is meant to be stateful, which is enabled by creating the transformation function anew for every materialization — the returned function will typically close over mutable objects to store state between invocations. For the stateless variant see FlowOps.mapConcat.

    The returned Iterable MUST NOT contain null values, as they are illegal as stream elements - according to the Reactive Streams specification.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the mapping function returns an element or there are still remaining elements from the previously calculated collection

    Backpressures when downstream backpressures or there are still remaining elements from the previously calculated collection

    Completes when upstream completes and all remaining elements has been emitted

    Cancels when downstream cancels

    See also FlowOps.mapConcat

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  141. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  142. def take(n: Long): Source[T, NotUsed]

    Terminate processing (and cancel the upstream publisher) after the given number of elements.

    Terminate processing (and cancel the upstream publisher) after the given number of elements. Due to input buffering some elements may have been requested from upstream publishers that will then not be processed downstream of this step.

    The stream will be completed without producing any elements if n is zero or negative.

    Emits when the specified number of elements to take has not yet been reached

    Backpressures when downstream backpressures

    Completes when the defined number of elements has been taken or upstream completes

    Cancels when the defined number of elements has been taken or downstream cancels

    See also FlowOps.limit, FlowOps.limitWeighted

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  143. def takeWhile(p: (T) => Boolean, inclusive: Boolean): Source[T, NotUsed]

    Terminate processing (and cancel the upstream publisher) after predicate returns false for the first time, including the first failed element iff inclusive is true Due to input buffering some elements may have been requested from upstream publishers that will then not be processed downstream of this step.

    Terminate processing (and cancel the upstream publisher) after predicate returns false for the first time, including the first failed element iff inclusive is true Due to input buffering some elements may have been requested from upstream publishers that will then not be processed downstream of this step.

    The stream will be completed without producing any elements if predicate is false for the first stream element.

    Adheres to the ActorAttributes.SupervisionStrategy attribute.

    Emits when the predicate is true

    Backpressures when downstream backpressures

    Completes when predicate returned false (or 1 after predicate returns false if inclusive or upstream completes

    Cancels when predicate returned false or downstream cancels

    See also FlowOps.limit, FlowOps.limitWeighted

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  144. def takeWhile(p: (T) => Boolean): Source[T, NotUsed]

    Terminate processing (and cancel the upstream publisher) after predicate returns false for the first time, Due to input buffering some elements may have been requested from upstream publishers that will then not be processed downstream of this step.

    Terminate processing (and cancel the upstream publisher) after predicate returns false for the first time, Due to input buffering some elements may have been requested from upstream publishers that will then not be processed downstream of this step.

    The stream will be completed without producing any elements if predicate is false for the first stream element.

    Emits when the predicate is true

    Backpressures when downstream backpressures

    Completes when predicate returned false (or 1 after predicate returns false if inclusive or upstream completes

    Cancels when predicate returned false or downstream cancels

    See also FlowOps.limit, FlowOps.limitWeighted

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  145. def takeWithin(d: FiniteDuration): Source[T, NotUsed]

    Terminate processing (and cancel the upstream publisher) after the given duration.

    Terminate processing (and cancel the upstream publisher) after the given duration. Due to input buffering some elements may have been requested from upstream publishers that will then not be processed downstream of this step.

    Note that this can be combined with #take to limit the number of elements within the duration.

    Emits when an upstream element arrives

    Backpressures when downstream backpressures

    Completes when upstream completes or timer fires

    Cancels when downstream cancels or timer fires

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  146. def throttle(cost: Int, per: FiniteDuration, maximumBurst: Int, costCalculation: (T) => Int, mode: ThrottleMode): Source[T, NotUsed]

    Sends elements downstream with speed limited to cost/per.

    Sends elements downstream with speed limited to cost/per. Cost is calculating for each element individually by calling calculateCost function. This operator works for streams when elements have different cost(length). Streams of ByteString for example.

    Throttle implements the token bucket model. There is a bucket with a given token capacity (burst size or maximumBurst). Tokens drops into the bucket at a given rate and can be spared for later use up to bucket capacity to allow some burstiness. Whenever stream wants to send an element, it takes as many tokens from the bucket as element costs. If there isn't any, throttle waits until the bucket accumulates enough tokens. Elements that costs more than the allowed burst will be delayed proportionally to their cost minus available tokens, meeting the target rate. Bucket is full when stream just materialized and started.

    Parameter mode manages behavior when upstream is faster than throttle rate:

    It is recommended to use non-zero burst sizes as they improve both performance and throttling precision by allowing the implementation to avoid using the scheduler when input rates fall below the enforced limit and to reduce most of the inaccuracy caused by the scheduler resolution (which is in the range of milliseconds).

    WARNING: Be aware that throttle is using scheduler to slow down the stream. This scheduler has minimal time of triggering next push. Consequently it will slow down the stream as it has minimal pause for emitting. This can happen in case burst is 0 and speed is higher than 30 events per second. You need to increase the maximumBurst if elements arrive with small interval (30 milliseconds or less). Use the overloaded throttle method without maximumBurst parameter to automatically calculate the maximumBurst based on the given rate (cost/per). In other words the throttler always enforces the rate limit when maximumBurst parameter is given, but in certain cases (mostly due to limited scheduler resolution) it enforces a tighter bound than what was prescribed.

    Emits when upstream emits an element and configured time per each element elapsed

    Backpressures when downstream backpressures or the incoming rate is higher than the speed limit

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  147. def throttle(cost: Int, per: FiniteDuration, costCalculation: (T) => Int): Source[T, NotUsed]

    Sends elements downstream with speed limited to cost/per.

    Sends elements downstream with speed limited to cost/per. Cost is calculating for each element individually by calling calculateCost function. This operator works for streams when elements have different cost(length). Streams of ByteString for example.

    Throttle implements the token bucket model. There is a bucket with a given token capacity (burst size). Tokens drops into the bucket at a given rate and can be spared for later use up to bucket capacity to allow some burstiness. Whenever stream wants to send an element, it takes as many tokens from the bucket as element costs. If there isn't any, throttle waits until the bucket accumulates enough tokens. Elements that costs more than the allowed burst will be delayed proportionally to their cost minus available tokens, meeting the target rate. Bucket is full when stream just materialized and started.

    The burst size is calculated based on the given rate (cost/per) as 0.1 * rate, for example: - rate < 20/second => burst size 1 - rate 20/second => burst size 2 - rate 100/second => burst size 10 - rate 200/second => burst size 20

    The throttle mode is akka.stream.ThrottleMode.Shaping, which makes pauses before emitting messages to meet throttle rate.

    Emits when upstream emits an element and configured time per each element elapsed

    Backpressures when downstream backpressures or the incoming rate is higher than the speed limit

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  148. def throttle(elements: Int, per: FiniteDuration, maximumBurst: Int, mode: ThrottleMode): Source[T, NotUsed]

    Sends elements downstream with speed limited to elements/per.

    Sends elements downstream with speed limited to elements/per. In other words, this operator set the maximum rate for emitting messages. This operator works for streams where all elements have the same cost or length.

    Throttle implements the token bucket model. There is a bucket with a given token capacity (burst size or maximumBurst). Tokens drops into the bucket at a given rate and can be spared for later use up to bucket capacity to allow some burstiness. Whenever stream wants to send an element, it takes as many tokens from the bucket as element costs. If there isn't any, throttle waits until the bucket accumulates enough tokens. Elements that costs more than the allowed burst will be delayed proportionally to their cost minus available tokens, meeting the target rate. Bucket is full when stream just materialized and started.

    Parameter mode manages behavior when upstream is faster than throttle rate:

    It is recommended to use non-zero burst sizes as they improve both performance and throttling precision by allowing the implementation to avoid using the scheduler when input rates fall below the enforced limit and to reduce most of the inaccuracy caused by the scheduler resolution (which is in the range of milliseconds).

    WARNING: Be aware that throttle is using scheduler to slow down the stream. This scheduler has minimal time of triggering next push. Consequently it will slow down the stream as it has minimal pause for emitting. This can happen in case burst is 0 and speed is higher than 30 events per second. You need to increase the maximumBurst if elements arrive with small interval (30 milliseconds or less). Use the overloaded throttle method without maximumBurst parameter to automatically calculate the maximumBurst based on the given rate (cost/per). In other words the throttler always enforces the rate limit when maximumBurst parameter is given, but in certain cases (mostly due to limited scheduler resolution) it enforces a tighter bound than what was prescribed.

    Emits when upstream emits an element and configured time per each element elapsed

    Backpressures when downstream backpressures or the incoming rate is higher than the speed limit

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  149. def throttle(elements: Int, per: FiniteDuration): Source[T, NotUsed]

    Sends elements downstream with speed limited to elements/per.

    Sends elements downstream with speed limited to elements/per. In other words, this operator set the maximum rate for emitting messages. This operator works for streams where all elements have the same cost or length.

    Throttle implements the token bucket model. There is a bucket with a given token capacity (burst size). Tokens drops into the bucket at a given rate and can be spared for later use up to bucket capacity to allow some burstiness. Whenever stream wants to send an element, it takes as many tokens from the bucket as element costs. If there isn't any, throttle waits until the bucket accumulates enough tokens. Elements that costs more than the allowed burst will be delayed proportionally to their cost minus available tokens, meeting the target rate. Bucket is full when stream just materialized and started.

    The burst size is calculated based on the given rate (cost/per) as 0.1 * rate, for example: - rate < 20/second => burst size 1 - rate 20/second => burst size 2 - rate 100/second => burst size 10 - rate 200/second => burst size 20

    The throttle mode is akka.stream.ThrottleMode.Shaping, which makes pauses before emitting messages to meet throttle rate.

    Emits when upstream emits an element and configured time per each element elapsed

    Backpressures when downstream backpressures or the incoming rate is higher than the speed limit

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  150. def to[Mat2](sink: Graph[SinkShape[T], Mat2]): RunnableGraph[NotUsed]

    Connect this akka.stream.scaladsl.Source to a akka.stream.scaladsl.Sink, concatenating the processing steps of both.

    Connect this akka.stream.scaladsl.Source to a akka.stream.scaladsl.Sink, concatenating the processing steps of both.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → FlowOps
  151. def toMat[Mat2, Mat3](sink: Graph[SinkShape[T], Mat2])(combine: (NotUsed, Mat2) => Mat3): RunnableGraph[Mat3]

    Connect this akka.stream.scaladsl.Source to a akka.stream.scaladsl.Sink, concatenating the processing steps of both.

    Connect this akka.stream.scaladsl.Source to a akka.stream.scaladsl.Sink, concatenating the processing steps of both.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → FlowOpsMat
  152. def toString(): String
    Definition Classes
    AnyRef → Any
  153. val traversalBuilder: LinearTraversalBuilder

    INTERNAL API.

    INTERNAL API.

    Every materializable element must be backed by a stream layout module

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → Graph
  154. def via[T, Mat2](flow: Graph[FlowShape[T, T], Mat2]): Source[T, NotUsed]

    Transform this Flow by appending the given processing steps.

    Transform this Flow by appending the given processing steps.

        +---------------------------------+
    | Resulting Flow[In, T, Mat]  |
    |                                 |
    |  +------+             +------+  |
    |  |      |             |      |  |
In ~~> | this |  ~~Out~~>   | flow | ~~> T
    |  |   Mat|             |     M|  |
    |  +------+             +------+  |
    +---------------------------------+

    The materialized value of the combined Flow will be the materialized value of the current flow (ignoring the other Flow’s value), use viaMat if a different strategy is needed.

    See also FlowOpsMat.viaMat when access to materialized values of the parameter is needed.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → FlowOps
  155. def viaMat[T, Mat2, Mat3](flow: Graph[FlowShape[T, T], Mat2])(combine: (NotUsed, Mat2) => Mat3): Source[T, Mat3]

    Transform this Flow by appending the given processing steps.

    Transform this Flow by appending the given processing steps.

        +---------------------------------+
    | Resulting Flow[In, T, M2]       |
    |                                 |
    |  +------+            +------+   |
    |  |      |            |      |   |
In ~~> | this |  ~~Out~~>  | flow |  ~~> T
    |  |   Mat|            |     M|   |
    |  +------+            +------+   |
    +---------------------------------+

    The combine function is used to compose the materialized values of this flow and that flow into the materialized value of the resulting Flow.

    It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → FlowOpsMat
  156. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  157. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  158. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  159. def watch(ref: ActorRef): Source[T, NotUsed]

    The operator fails with an akka.stream.WatchedActorTerminatedException if the target actor is terminated.

    The operator fails with an akka.stream.WatchedActorTerminatedException if the target actor is terminated.

    Emits when upstream emits

    Backpressures when downstream backpressures

    Completes when upstream completes

    Fails when the watched actor terminates

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  160. def watchTermination[Mat2]()(matF: (NotUsed, Future[Done]) => Mat2): Source[T, Mat2]

    Materializes to Future[Done] that completes on getting termination message.

    Materializes to Future[Done] that completes on getting termination message. The Future completes with success when received complete message from upstream or cancel from downstream. It fails with the propagated error when received error message from upstream or downstream.

    It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
  161. def wireTap(that: Graph[SinkShape[T], _]): Source[T, NotUsed]

    Attaches the given Sink to this Flow as a wire tap, meaning that elements that pass through will also be sent to the wire-tap Sink, without the latter affecting the mainline flow.

    Attaches the given Sink to this Flow as a wire tap, meaning that elements that pass through will also be sent to the wire-tap Sink, without the latter affecting the mainline flow. If the wire-tap Sink backpressures, elements that would've been sent to it will be dropped instead.

    It is similar to #alsoTo which does backpressure instead of dropping elements.

    Emits when element is available and demand exists from the downstream; the element will also be sent to the wire-tap Sink if there is demand.

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  162. def wireTap(f: (T) => Unit): Source[T, NotUsed]

    This is a simplified version of wireTap(Sink) that takes only a simple function.

    This is a simplified version of wireTap(Sink) that takes only a simple function. Elements will be passed into this "side channel" function, and any of its results will be ignored.

    If the wire-tap operation is slow (it backpressures), elements that would've been sent to it will be dropped instead. It is similar to #alsoTo which does backpressure instead of dropping elements.

    This operation is useful for inspecting the passed through element, usually by means of side-effecting operations (such as println, or emitting metrics), for each element without having to modify it.

    For logging signals (elements, completion, error) consider using the log operator instead, along with appropriate ActorAttributes.logLevels.

    Emits when upstream emits an element; the same element will be passed to the attached function, as well as to the downstream operator

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  163. def wireTapMat[Mat2, Mat3](that: Graph[SinkShape[T], Mat2])(matF: (NotUsed, Mat2) => Mat3): Source[T, Mat3]

    Attaches the given Sink to this Flow as a wire tap, meaning that elements that pass through will also be sent to the wire-tap Sink, without the latter affecting the mainline flow.

    Attaches the given Sink to this Flow as a wire tap, meaning that elements that pass through will also be sent to the wire-tap Sink, without the latter affecting the mainline flow. If the wire-tap Sink backpressures, elements that would've been sent to it will be dropped instead.

    It is similar to #alsoToMat which does backpressure instead of dropping elements.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #wireTap It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  164. def withAttributes(attr: Attributes): Source[T, NotUsed]

    Replace the attributes of this Source with the given ones.

    Replace the attributes of this Source with the given ones. If this Source is a composite of multiple graphs, new attributes on the composite will be less specific than attributes set directly on the individual graphs of the composite.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    Source → Graph → FlowOps
  165. def zip[U](that: Graph[SourceShape[U], _]): Source[(T, U), NotUsed]

    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.

    Emits when all of the inputs have an element available

    Backpressures when downstream backpressures

    Completes when any upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  166. def zipAll[U, A >: Out](that: Graph[SourceShape[U], _], thisElem: A, thatElem: U): Source[(A, U), NotUsed]

    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.

    Emits when at first emits when both inputs emit, and then as long as any input emits (coupled to the default value of the completed input).

    Backpressures when downstream backpressures

    Completes when all upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  167. def zipAllMat[U, Mat2, Mat3, A >: Out](that: Graph[SourceShape[U], Mat2], thisElem: A, thatElem: U)(matF: (NotUsed, Mat2) => Mat3): Source[(A, U), Mat3]

    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.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #zipAll Emits when at first emits when both inputs emit, and then as long as any input emits (coupled to the default value of the completed input). Backpressures when downstream backpressures Completes when all upstream completes Cancels when downstream cancels

  168. def zipLatest[U](that: Graph[SourceShape[U], _]): Source[(T, U), NotUsed]

    Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.

    Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.

    A ZipLatest has a left and a right input port and one out port.

    No element is emitted until at least one element from each Source becomes available.

    Emits when all of the inputs have at least an element available, and then each time an element becomes available on either of the inputs

    Backpressures when downstream backpressures

    Completes when any upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  169. def zipLatestMat[U, Mat2, Mat3](that: Graph[SourceShape[U], Mat2])(matF: (NotUsed, Mat2) => Mat3): Source[(T, U), Mat3]

    Combine the elements of current flow and the given Source into a stream of tuples, picking always the latest of the elements of each source.

    Combine the elements of current flow and the given Source into a stream of tuples, picking always the latest of the elements of each source.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #zipLatest. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  170. def zipLatestWith[Out2, Out3](that: Graph[SourceShape[Out2], _], eagerComplete: Boolean)(combine: (T, Out2) => Out3): Source[Out3, NotUsed]

    Combine the elements of multiple streams into a stream of combined elements using a combiner function, picking always the latest of the elements of each source.

    Combine the elements of multiple streams into a stream of combined elements using a combiner function, picking always the latest of the elements of each source.

    No element is emitted until at least one element from each Source becomes available. Whenever a new element appears, the zipping function is invoked with a tuple containing the new element and the other last seen elements.

    Emits when all of the inputs have at least an element available, and then each time an element becomes available on either of the inputs

    Backpressures when downstream backpressures

    Completes when any upstream completes if eagerComplete is enabled or wait for all upstreams to complete

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  171. def zipLatestWith[Out2, Out3](that: Graph[SourceShape[Out2], _])(combine: (T, Out2) => Out3): Source[Out3, NotUsed]

    Combine the elements of multiple streams into a stream of combined elements using a combiner function, picking always the latest of the elements of each source.

    Combine the elements of multiple streams into a stream of combined elements using a combiner function, picking always the latest of the elements of each source.

    No element is emitted until at least one element from each Source becomes available. Whenever a new element appears, the zipping function is invoked with a tuple containing the new element and the other last seen elements.

    Emits when all of the inputs have at least an element available, and then each time an element becomes available on either of the inputs

    Backpressures when downstream backpressures

    Completes when any of the upstreams completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  172. def zipLatestWithMat[Out2, Out3, Mat2, Mat3](that: Graph[SourceShape[Out2], Mat2], eagerComplete: Boolean)(combine: (T, Out2) => Out3)(matF: (NotUsed, Mat2) => Mat3): Source[Out3, Mat3]

    Put together the elements of current flow and the given Source into a stream of combined elements using a combiner function, picking always the latest of the elements of each source.

    Put together the elements of current flow and the given Source into a stream of combined elements using a combiner function, picking always the latest of the elements of each source.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #zipLatestWith. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  173. def zipLatestWithMat[Out2, Out3, Mat2, Mat3](that: Graph[SourceShape[Out2], Mat2])(combine: (T, Out2) => Out3)(matF: (NotUsed, Mat2) => Mat3): Source[Out3, Mat3]

    Put together the elements of current flow and the given Source into a stream of combined elements using a combiner function, picking always the latest of the elements of each source.

    Put together the elements of current flow and the given Source into a stream of combined elements using a combiner function, picking always the latest of the elements of each source.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #zipLatestWith. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  174. def zipMat[U, Mat2, Mat3](that: Graph[SourceShape[U], Mat2])(matF: (NotUsed, Mat2) => Mat3): Source[(T, U), Mat3]

    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.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #zip. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

  175. def zipWith[Out2, Out3](that: Graph[SourceShape[Out2], _])(combine: (T, Out2) => Out3): Source[Out3, NotUsed]

    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.

    Emits when all of the inputs have an element available

    Backpressures when downstream backpressures

    Completes when any upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  176. def zipWithIndex: Source[(T, Long), NotUsed]

    Combine the elements of current flow into a stream of tuples consisting of all elements paired with their index.

    Combine the elements of current flow into a stream of tuples consisting of all elements paired with their index. Indices start at 0.

    Emits when upstream emits an element and is paired with their index

    Backpressures when downstream backpressures

    Completes when upstream completes

    Cancels when downstream cancels

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOps
  177. def zipWithMat[Out2, Out3, Mat2, Mat3](that: Graph[SourceShape[Out2], Mat2])(combine: (T, Out2) => Out3)(matF: (NotUsed, Mat2) => Mat3): Source[Out3, Mat3]

    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.

    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Definition Classes
    FlowOpsMat
    See also

    #zipWith. It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

Shadowed Implicit Value Members

  1. def toString(): String
    Implicit
    This member is added by an implicit conversion from SourceRef[T] toSource[T, NotUsed] performed by method convertRefToSource in akka.stream.SourceRef.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (sourceRef: Source[T, NotUsed]).toString()
    Definition Classes
    Source → AnyRef → Any

Deprecated Value Members

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

    (Since version 9)

  2. def formatted(fmtstr: String): String
    Implicit
    This member is added by an implicit conversion from SourceRef[T] toStringFormat[SourceRef[T]] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @deprecated @inline()
    Deprecated

    (Since version 2.12.16) Use formatString.format(value) instead of value.formatted(formatString), or use the f"" string interpolator. In Java 15 and later, formatted resolves to the new method in String which has reversed parameters.

  3. def →[B](y: B): (SourceRef[T], B)
    Implicit
    This member is added by an implicit conversion from SourceRef[T] toArrowAssoc[SourceRef[T]] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use -> instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion convertRefToSource fromSourceRef[T] to Source[T, NotUsed]

Inherited by implicit conversion any2stringadd fromSourceRef[T] to any2stringadd[SourceRef[T]]

Inherited by implicit conversion StringFormat fromSourceRef[T] to StringFormat[SourceRef[T]]

Inherited by implicit conversion Ensuring fromSourceRef[T] to Ensuring[SourceRef[T]]

Inherited by implicit conversion ArrowAssoc fromSourceRef[T] to ArrowAssoc[SourceRef[T]]

Ungrouped