Package akka.stream.scaladsl

Class Concat<T>

java.lang.Object

akka.stream.stage.GraphStageWithMaterializedValue<S,NotUsed>

akka.stream.stage.GraphStage<UniformFanInShape<T,T>>

akka.stream.scaladsl.Concat<T>

All Implemented Interfaces:

Graph<UniformFanInShape<T,T>,NotUsed>

public final class Concat<T>
extends GraphStage<UniformFanInShape<T,T>>

Takes multiple streams and outputs one stream formed from the input streams by first emitting all of the elements from the first stream and then emitting all of the elements from the second stream, etc.

A Concat has one first port, one second port and one out port.

'''Emits when''' the current stream has an element available; if the current input completes, it tries the next one

'''Backpressures when''' downstream backpressures

'''Completes when''' all upstreams complete

'''Cancels when''' downstream cancels

Nested Class Summary

Nested classes/interfaces inherited from interface akka.stream.Graph

Graph.GraphMapMatVal<S extends Shape,M>

Constructor Summary

Constructors

Constructor	Description
Concat(int inputPorts)

Method Summary

Modifier and Type	Method	Description
static <T> Graph<UniformFanInShape<T,T>,NotUsed>	apply(int inputPorts)	Create a new Concat.
static <T> Graph<UniformFanInShape<T,T>,NotUsed>	apply(int inputPorts, boolean detachedInputs)	Create a new Concat operator that will concatenate two or more streams.
static <T> int	apply$default$1()
GraphStageLogic	createLogic(Attributes inheritedAttributes)
scala.collection.immutable.IndexedSeq<Inlet<T>>	in()
Attributes	initialAttributes()
int	inputPorts()
Outlet<T>	out()
UniformFanInShape<T,T>	shape()	The shape of a graph is all that is externally visible: its inlets and outlets.
java.lang.String	toString()

Methods inherited from class akka.stream.stage.GraphStage

createLogicAndMaterializedValue

Methods inherited from class akka.stream.stage.GraphStageWithMaterializedValue

withAttributes

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface akka.stream.Graph

addAttributes, async, async, async, getAttributes, named

Constructor Detail

Concat

public Concat(int inputPorts)

Method Detail

apply

public static <T> Graph<UniformFanInShape<T,T>,NotUsed> apply(int inputPorts)

Create a new Concat. Note that this for historical reasons creates a "detached" Concat which will eagerly pull each input on materialization and act as a one element buffer for each input.

apply

public static <T> Graph<UniformFanInShape<T,T>,NotUsed> apply(int inputPorts,
                                                                          boolean detachedInputs)

Create a new Concat operator that will concatenate two or more streams.

Parameters:

inputPorts - The number of fan-in input ports

detachedInputs - If the ports should be detached (eagerly pull both inputs) useful to avoid deadlocks in graphs with loops

Returns:

apply$default$1

public static <T> int apply$default$1()

inputPorts

public int inputPorts()

in

public scala.collection.immutable.IndexedSeq<Inlet<T>> in()

out

public Outlet<T> out()

initialAttributes

public Attributes initialAttributes()

Overrides:

initialAttributes in class GraphStageWithMaterializedValue<UniformFanInShape<T,T>,NotUsed>

shape

public UniformFanInShape<T,T> shape()

Description copied from interface: Graph

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

createLogic

public GraphStageLogic createLogic(Attributes inheritedAttributes)

Specified by:

createLogic in class GraphStage<UniformFanInShape<T,T>>

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object