Source

java.lang.Object
- akka.stream.scaladsl.Source<Out,Mat>

All Implemented Interfaces:

Graph<SourceShape<Out>,Mat>, FlowOps<Out,Mat>, FlowOpsMat<Out,Mat>
```
public final class Source<Out,Mat>
extends java.lang.Object
implements FlowOpsMat<Out,Mat>, Graph<SourceShape<Out>,Mat>
```
A Source is a set of stream processing steps that has one open output. It can comprise any number of internal sources and transformations that are wired together, or it can be an “atomic” source, e.g. from a collection or a file. Materialization turns a Source into a Reactive Streams Publisher (at least conceptually).

Constructor Summary

Constructors
Constructor and Description

Source(StreamLayout.Module module)

Constructors
Constructor and Description
`Source(StreamLayout.Module module)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static <U,M> FlowOps`	`$plus$plus(Graph<SourceShape<U>,M> that)`
`static <T> Source<T,ActorRef>`	`actorPublisher(Props props)` Creates a `Source` that is materialized to an `ActorRef` which points to an Actor created according to the passed in `Props`.
`static <T> Source<T,ActorRef>`	`actorRef(int bufferSize, OverflowStrategy overflowStrategy)` Creates a `Source` that is materialized as an `ActorRef`.
`Source<Out,Mat>`	`addAttributes(Attributes attr)` Add the given attributes to this Source.
`static FlowOps`	`alsoTo(Graph<SinkShape<Out>,?> that)`
`protected static <M> Graph<FlowShape<Out,Out>,M>`	`alsoToGraph(Graph<SinkShape<Out>,M> that)`
`static <Mat2,Mat3> FlowOpsMat`	`alsoToMat(Graph<SinkShape<Out>,Mat2> that, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <T> FlowOps`	`andThen(Stages.SymbolicStage<Out,T> op)`
`static <T> Source<T,NotUsed>`	`apply(scala.collection.immutable.Iterable<T> iterable)` Helper to create `Source` from `Iterable`.
`Source<Out,Mat>`	`asJava()` Converts this Scala DSL element to it's Java DSL counterpart.
`static <T> Source<T,org.reactivestreams.Subscriber<T>>`	`asSubscriber()` Creates a `Source` that is materialized as a `Subscriber`
`Source<Out,Mat>`	`async()` Put an asynchronous boundary around this `Source`
`static FlowOps`	`backpressureTimeout(scala.concurrent.duration.FiniteDuration timeout)`
`static <S> FlowOps`	`batch(long max, scala.Function1<Out,S> seed, scala.Function2<S,Out,S> aggregate)`
`static <S> FlowOps`	`batchWeighted(long max, scala.Function1<Out,java.lang.Object> costFn, scala.Function1<Out,S> seed, scala.Function2<S,Out,S> aggregate)`
`static FlowOps`	`buffer(int size, OverflowStrategy overflowStrategy)`
`static <T> FlowOps`	`collect(scala.PartialFunction<Out,T> pf)`
`<T,U> Source<U,NotUsed>`	`combine(Source<T,?> first, Source<T,?> second, scala.collection.Seq<Source<T,?>> rest, scala.Function1<java.lang.Object,Graph<UniformFanInShape<T,U>,NotUsed>> strategy)` Combines several sources with fun-in strategy like `Merge` or `Concat` and returns `Source`.
`static FlowOps`	`completionTimeout(scala.concurrent.duration.FiniteDuration timeout)`
`static <U,Mat2> FlowOps`	`concat(Graph<SourceShape<U>,Mat2> that)`
`protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2>`	`concatGraph(Graph<SourceShape<U>,Mat2> that)`
`static <U,Mat2,Mat3> FlowOpsMat`	`concatMat(Graph<SourceShape<U>,Mat2> that, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <O2> FlowOps`	`conflate(scala.Function2<O2,O2,O2> aggregate)`
`static <S> FlowOps`	`conflateWithSeed(scala.Function1<Out,S> seed, scala.Function2<S,Out,S> aggregate)`
`static <T> Source<T,NotUsed>`	`cycle(scala.Function0<scala.collection.Iterator<T>> f)` Create `Source` that will continually produce given elements in specified order.
`static FlowOps`	`delay(scala.concurrent.duration.FiniteDuration of, DelayOverflowStrategy strategy)`
`static DelayOverflowStrategy`	`delay$default$2()`
`static FlowOps`	`detach()`
`static FlowOps`	`drop(long n)`
`static FlowOps`	`dropWhile(scala.Function1<Out,java.lang.Object> p)`
`static FlowOps`	`dropWithin(scala.concurrent.duration.FiniteDuration d)`
`static <T> Source<T,NotUsed>`	`empty()` A `Source` with no elements, i.e.
`static <U> FlowOps`	`expand(scala.Function1<Out,scala.collection.Iterator<U>> extrapolate)`
`static <T> Source<T,NotUsed>`	`failed(java.lang.Throwable cause)` Create a `Source` that immediately ends the stream with the `cause` error to every connected `Sink`.
`static FlowOps`	`filter(scala.Function1<Out,java.lang.Object> p)`
`static FlowOps`	`filterNot(scala.Function1<Out,java.lang.Object> p)`
`static <T,M> FlowOps`	`flatMapConcat(scala.Function1<Out,Graph<SourceShape<T>,M>> f)`
`static <T,M> FlowOps`	`flatMapMerge(int breadth, scala.Function1<Out,Graph<SourceShape<T>,M>> f)`
`static <T> FlowOps`	`fold(T zero, scala.Function2<T,Out,T> f)`
`static <T> FlowOps`	`foldAsync(T zero, scala.Function2<T,Out,scala.concurrent.Future<T>> f)`
`static <T> Source<T,NotUsed>`	`fromCompletionStage(java.util.concurrent.CompletionStage<T> future)` Start a new `Source` from the given `Future`.
`static <T> Source<T,NotUsed>`	`fromFuture(scala.concurrent.Future<T> future)` Start a new `Source` from the given `Future`.
`static <T,M> Source<T,M>`	`fromGraph(Graph<SourceShape<T>,M> g)` A graph with the shape of a source logically is a source, this method makes it so also in type.
`static <T> Source<T,NotUsed>`	`fromIterator(scala.Function0<scala.collection.Iterator<T>> f)` Helper to create `Source` from `Iterator`.
`static <T> Source<T,NotUsed>`	`fromPublisher(org.reactivestreams.Publisher<T> publisher)` Helper to create `Source` from `Publisher`.
`static <K> SubFlow<Out,Mat,FlowOps,java.lang.Object>`	`groupBy(int maxSubstreams, scala.Function1<Out,K> f)`
`static FlowOps`	`grouped(int n)`
`static FlowOps`	`groupedWithin(int n, scala.concurrent.duration.FiniteDuration d)`
`static FlowOps`	`idleTimeout(scala.concurrent.duration.FiniteDuration timeout)`
`static FlowOps`	`initialDelay(scala.concurrent.duration.FiniteDuration delay)`
`static FlowOps`	`initialTimeout(scala.concurrent.duration.FiniteDuration timeout)`
`static <U> FlowOps`	`interleave(Graph<SourceShape<U>,?> that, int segmentSize)`
`protected static <U,M> Graph<FlowShape<Out,U>,M>`	`interleaveGraph(Graph<SourceShape<U>,M> that, int segmentSize)`
`static <U,Mat2,Mat3> FlowOpsMat`	`interleaveMat(Graph<SourceShape<U>,Mat2> that, int request, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <T> FlowOps`	`intersperse(T inject)`
`static <T> FlowOps`	`intersperse(T start, T inject, T end)`
`static <U> FlowOps`	`keepAlive(scala.concurrent.duration.FiniteDuration maxIdle, scala.Function0<U> injectedElem)`
`static <T,M> Source<T,scala.concurrent.Future<M>>`	`lazily(scala.Function0<Source<T,M>> create)` Creates a `Source` that is not materialized until there is downstream demand, when the source gets materialized the materialized future is completed with its value, if downstream cancels or fails without any demand the create factory is never called and the materialized `Future` is failed.
`static FlowOps`	`limit(long max)`
`static <T> FlowOps`	`limitWeighted(long max, scala.Function1<Out,java.lang.Object> costFn)`
`static FlowOps`	`log(java.lang.String name, scala.Function1<Out,java.lang.Object> extract, LoggingAdapter log)`
`static scala.Function1<Out,java.lang.Object>`	`log$default$2()`
`static LoggingAdapter`	`log$default$3(java.lang.String name, scala.Function1<Out,java.lang.Object> extract)`
`static <T> FlowOps`	`map(scala.Function1<Out,T> f)`
`static <T> FlowOps`	`mapAsync(int parallelism, scala.Function1<Out,scala.concurrent.Future<T>> f)`
`static <T> FlowOps`	`mapAsyncUnordered(int parallelism, scala.Function1<Out,scala.concurrent.Future<T>> f)`
`static <T> FlowOps`	`mapConcat(scala.Function1<Out,scala.collection.immutable.Iterable<T>> f)`
`static FlowOps`	`mapError(scala.PartialFunction<java.lang.Throwable,java.lang.Throwable> pf)`
`<Mat2> Source<Out,Mat2>`	`mapMaterializedValue(scala.Function1<Mat,Mat2> f)` Transform only the materialized value of this Source, leaving all other properties as they were.
`static <T> Source<T,scala.concurrent.Promise<scala.Option<T>>>`	`maybe()` Create a `Source` which materializes a `Promise` which controls what element will be emitted by the Source.
`static <U,M> FlowOps`	`merge(Graph<SourceShape<U>,M> that, boolean eagerComplete)`
`static <U,M> boolean`	`merge$default$2()`
`protected static <U,M> Graph<FlowShape<Out,U>,M>`	`mergeGraph(Graph<SourceShape<U>,M> that, boolean eagerComplete)`
`static <U,Mat2,Mat3> FlowOpsMat`	`mergeMat(Graph<SourceShape<U>,Mat2> that, boolean eagerComplete, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <U,Mat2,Mat3> boolean`	`mergeMat$default$2()`
`static <U,M> FlowOps`	`mergeSorted(Graph<SourceShape<U>,M> that, scala.math.Ordering<U> ord)`
`protected static <U,M> Graph<FlowShape<Out,U>,M>`	`mergeSortedGraph(Graph<SourceShape<U>,M> that, scala.math.Ordering<U> ord)`
`static <U,Mat2,Mat3> FlowOpsMat`	`mergeSortedMat(Graph<SourceShape<U>,Mat2> that, scala.Function2<Mat,Mat2,Mat3> matF, scala.math.Ordering<U> ord)`
`StreamLayout.Module`	`module()` INTERNAL API.
`static <Mat2> FlowOpsMat`	`monitor(scala.Function2<Mat,FlowMonitor<Out>,Mat2> combine)`
`Source<Out,Mat>`	`named(java.lang.String name)` Add a name attribute to this Source.
`static <U,Mat2> FlowOps`	`orElse(Graph<SourceShape<U>,Mat2> secondary)`
`protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2>`	`orElseGraph(Graph<SourceShape<U>,Mat2> secondary)`
`static <U,Mat2,Mat3> FlowOpsMat`	`orElseMat(Graph<SourceShape<U>,Mat2> secondary, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <U> FlowOps`	`prefixAndTail(int n)`
`static <U,Mat2> FlowOps`	`prepend(Graph<SourceShape<U>,Mat2> that)`
`protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2>`	`prependGraph(Graph<SourceShape<U>,Mat2> that)`
`static <U,Mat2,Mat3> FlowOpsMat`	`prependMat(Graph<SourceShape<U>,Mat2> that, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <T> Source<T,SourceQueueWithComplete<T>>`	`queue(int bufferSize, OverflowStrategy overflowStrategy)` Creates a `Source` that is materialized as an `SourceQueue`.
`static <T> FlowOps`	`recover(scala.PartialFunction<java.lang.Throwable,T> pf)`
`static <T> FlowOps`	`recoverWith(scala.PartialFunction<java.lang.Throwable,Graph<SourceShape<T>,NotUsed>> pf)`
`static <T> FlowOps`	`recoverWithRetries(int attempts, scala.PartialFunction<java.lang.Throwable,Graph<SourceShape<T>,NotUsed>> pf)`
`static <T> FlowOps`	`reduce(scala.Function2<T,T,T> f)`
`static <T> Source<T,NotUsed>`	`repeat(T element)` Create a `Source` that will continually emit the given element.
`<U> scala.concurrent.Future<U>`	`runFold(U zero, scala.Function2<U,Out,U> f, Materializer materializer)` Shortcut for running this `Source` with a fold function.
`<U> scala.concurrent.Future<U>`	`runFoldAsync(U zero, scala.Function2<U,Out,scala.concurrent.Future<U>> f, Materializer materializer)` Shortcut for running this `Source` with a foldAsync function.
`scala.concurrent.Future<Done>`	`runForeach(scala.Function1<Out,scala.runtime.BoxedUnit> f, Materializer materializer)` Shortcut for running this `Source` with a foreach procedure.
`<U> scala.concurrent.Future<U>`	`runReduce(scala.Function2<U,U,U> f, Materializer materializer)` Shortcut for running this `Source` with a reduce function.
`<Mat2> Mat2`	`runWith(Graph<SinkShape<Out>,Mat2> sink, Materializer materializer)` Connect this `Source` to a `Sink` and run it.
`static <T> FlowOps`	`scan(T zero, scala.Function2<T,Out,T> f)`
`static <T> FlowOps`	`scanAsync(T zero, scala.Function2<T,Out,scala.concurrent.Future<T>> f)`
`SourceShape<Out>`	`shape()` The shape of a graph is all that is externally visible: its inlets and outlets.
`static <T> Source<T,NotUsed>`	`single(T element)` Create a `Source` with one element.
`static FlowOps`	`sliding(int n, int step)`
`static int`	`sliding$default$2()`
`static SubFlow<Out,Mat,FlowOps,java.lang.Object>`	`splitAfter(scala.Function1<Out,java.lang.Object> p)`
`static SubFlow<Out,Mat,FlowOps,java.lang.Object>`	`splitAfter(SubstreamCancelStrategy substreamCancelStrategy, scala.Function1<Out,java.lang.Object> p)`
`static SubFlow<Out,Mat,FlowOps,java.lang.Object>`	`splitWhen(scala.Function1<Out,java.lang.Object> p)`
`static SubFlow<Out,Mat,FlowOps,java.lang.Object>`	`splitWhen(SubstreamCancelStrategy substreamCancelStrategy, scala.Function1<Out,java.lang.Object> p)`
`static <T> FlowOps`	`statefulMapConcat(scala.Function0<scala.Function1<Out,scala.collection.immutable.Iterable<T>>> f)`
`static FlowOps`	`take(long n)`
`static FlowOps`	`takeWhile(scala.Function1<Out,java.lang.Object> p)`
`static FlowOps`	`takeWhile(scala.Function1<Out,java.lang.Object> p, boolean inclusive)`
`static FlowOps`	`takeWithin(scala.concurrent.duration.FiniteDuration d)`
`static FlowOps`	`throttle(int cost, scala.concurrent.duration.FiniteDuration per, int maximumBurst, scala.Function1<Out,java.lang.Object> costCalculation, ThrottleMode mode)`
`static FlowOps`	`throttle(int elements, scala.concurrent.duration.FiniteDuration per, int maximumBurst, ThrottleMode mode)`
`static <T> Source<T,Cancellable>`	`tick(scala.concurrent.duration.FiniteDuration initialDelay, scala.concurrent.duration.FiniteDuration interval, T tick)` Elements are emitted periodically with the specified interval.
`<Mat2> RunnableGraph<Mat>`	`to(Graph<SinkShape<Out>,Mat2> sink)` Connect this `Source` to a `Sink`, concatenating the processing steps of both.
`<Mat2,Mat3> RunnableGraph<Mat3>`	`toMat(Graph<SinkShape<Out>,Mat2> sink, scala.Function2<Mat,Mat2,Mat3> combine)` Connect this `Source` to a `Sink`, concatenating the processing steps of both.
`java.lang.String`	`toString()`
`static <T> FlowOps`	`transform(scala.Function0<Stage<Out,T>> mkStage)`
`static <T,M> FlowOpsMat`	`transformMaterializing(scala.Function0<scala.Tuple2<Stage<Out,T>,M>> mkStageAndMaterialized)`
`static <S,E> Source<E,NotUsed>`	`unfold(S s, scala.Function1<S,scala.Option<scala.Tuple2<S,E>>> f)` Create a `Source` that will unfold a value of type `S` into a pair of the next state `S` and output elements of type `E`.
`static <S,E> Source<E,NotUsed>`	`unfoldAsync(S s, scala.Function1<S,scala.concurrent.Future<scala.Option<scala.Tuple2<S,E>>>> f)` Same as `unfold`, but uses an async function to generate the next state-element tuple.
`static <T,S> Source<T,NotUsed>`	`unfoldResource(scala.Function0<S> create, scala.Function1<S,scala.Option<T>> read, scala.Function1<S,scala.runtime.BoxedUnit> close)` Start a new `Source` from some resource which can be opened, read and closed.
`static <T,S> Source<T,NotUsed>`	`unfoldResourceAsync(scala.Function0<scala.concurrent.Future<S>> create, scala.Function1<S,scala.concurrent.Future<scala.Option<T>>> read, scala.Function1<S,scala.concurrent.Future<Done>> close)` Start a new `Source` from some resource which can be opened, read and closed.
`<T,Mat2> Source<T,Mat>`	`via(Graph<FlowShape<Out,T>,Mat2> flow)`
`<T,Mat2,Mat3> Source<T,Mat3>`	`viaMat(Graph<FlowShape<Out,T>,Mat2> flow, scala.Function2<Mat,Mat2,Mat3> combine)` Transform this `Flow` by appending the given processing steps.
`static <Mat2> FlowOpsMat`	`watchTermination(scala.Function2<Mat,scala.concurrent.Future<Done>,Mat2> matF)`
`Source<Out,Mat>`	`withAttributes(Attributes attr)` Change the attributes of this `Source` to the given ones and seal the list of attributes.
`static <U> FlowOps`	`zip(Graph<SourceShape<U>,?> that)`
`protected static <U,M> Graph<FlowShape<Out,scala.Tuple2<Out,U>>,M>`	`zipGraph(Graph<SourceShape<U>,M> that)`
`static <U,Mat2,Mat3> FlowOpsMat`	`zipMat(Graph<SourceShape<U>,Mat2> that, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <T> Source<scala.collection.immutable.Seq<T>,NotUsed>`	`zipN(scala.collection.immutable.Seq<Source<T,?>> sources)` Combine the elements of multiple streams into a stream of sequences.
`static <Out2,Out3> FlowOps`	`zipWith(Graph<SourceShape<Out2>,?> that, scala.Function2<Out,Out2,Out3> combine)`
`protected static <Out2,Out3,M> Graph<FlowShape<Out,Out3>,M>`	`zipWithGraph(Graph<SourceShape<Out2>,M> that, scala.Function2<Out,Out2,Out3> combine)`
`static FlowOps`	`zipWithIndex()`
`static <Out2,Out3,Mat2,Mat3> FlowOpsMat`	`zipWithMat(Graph<SourceShape<Out2>,Mat2> that, scala.Function2<Out,Out2,Out3> combine, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <T,O> Source<O,NotUsed>`	`zipWithN(scala.Function1<scala.collection.immutable.Seq<T>,O> zipper, scala.collection.immutable.Seq<Source<T,?>> sources)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface akka.stream.scaladsl.FlowOpsMat
alsoToMat, concatMat, interleaveMat, mergeMat, mergeSortedMat, monitor, orElseMat, prependMat, transformMaterializing, watchTermination, zipMat, zipWithMat

Methods inherited from interface akka.stream.scaladsl.FlowOps
alsoTo, alsoToGraph, andThen, backpressureTimeout, batch, batchWeighted, buffer, collect, completionTimeout, concat, concatGraph, conflate, conflateWithSeed, delay, detach, drop, dropWhile, dropWithin, expand, filter, filterNot, flatMapConcat, flatMapMerge, fold, foldAsync, groupBy, grouped, groupedWithin, idleTimeout, initialDelay, initialTimeout, interleave, interleaveGraph, intersperse, intersperse, keepAlive, limit, limitWeighted, log, map, mapAsync, mapAsyncUnordered, mapConcat, mapError, merge, mergeGraph, mergeSorted, mergeSortedGraph, orElse, orElseGraph, prefixAndTail, prepend, prependGraph, recover, recoverWith, recoverWithRetries, reduce, scan, scanAsync, sliding, splitAfter, splitAfter, splitWhen, splitWhen, statefulMapConcat, take, takeWhile, takeWhile, takeWithin, throttle, throttle, transform, zip, zipGraph, zipWith, zipWithGraph, zipWithIndex

Constructor Detail

Source

public Source(StreamLayout.Module module)

Method Detail

fromPublisher
```
public static <T> Source<T,NotUsed> fromPublisher(org.reactivestreams.Publisher<T> publisher)
```
Helper to create Source from Publisher.
Construct a transformation starting with given publisher. The transformation steps are executed by a series of Processor instances that mediate the flow of elements downstream and the propagation of back-pressure upstream.

Parameters:

publisher - (undocumented)

Returns:

(undocumented)

fromIterator
```
public static <T> Source<T,NotUsed> fromIterator(scala.Function0<scala.collection.Iterator<T>> f)
```
Helper to create Source from Iterator. Example usage: Source.fromIterator(() => Iterator.from(0))
Start a new Source from the given function that produces anIterator. The produced stream of elements will continue until the iterator runs empty or fails during evaluation of the next() method. Elements are pulled out of the iterator in accordance with the demand coming from the downstream transformation steps.

Parameters:

f - (undocumented)

Returns:

(undocumented)

cycle
```
public static <T> Source<T,NotUsed> cycle(scala.Function0<scala.collection.Iterator<T>> f)
```
Create Source that will continually produce given elements in specified order.
Start a new 'cycled' Source from the given elements. The producer stream of elements will continue infinitely by repeating the sequence of elements provided by function parameter.

Parameters:

f - (undocumented)

Returns:

(undocumented)

fromGraph
```
public static <T,M> Source<T,M> fromGraph(Graph<SourceShape<T>,M> g)
```
A graph with the shape of a source logically is a source, this method makes it so also in type.

Parameters:

g - (undocumented)

Returns:

(undocumented)

apply
```
public static <T> Source<T,NotUsed> apply(scala.collection.immutable.Iterable<T> iterable)
```
Helper to create Source from Iterable. Example usage: Source(Seq(1,2,3))
Starts a new Source from the given Iterable. This is like starting from an Iterator, but every Subscriber directly attached to the Publisher of this stream will see an individual flow of elements (always starting from the beginning) regardless of when they subscribed.

Parameters:

iterable - (undocumented)

Returns:

(undocumented)

fromFuture
```
public static <T> Source<T,NotUsed> fromFuture(scala.concurrent.Future<T> future)
```
Start a new Source from the given Future. The stream will consist of one element when the Future is completed with a successful value, which may happen before or after materializing the Flow. The stream terminates with a failure if the Future is completed with a failure.

Parameters:

future - (undocumented)

Returns:

(undocumented)

fromCompletionStage
```
public static <T> Source<T,NotUsed> fromCompletionStage(java.util.concurrent.CompletionStage<T> future)
```
Start a new Source from the given Future. The stream will consist of one element when the Future is completed with a successful value, which may happen before or after materializing the Flow. The stream terminates with a failure if the Future is completed with a failure.

Parameters:

future - (undocumented)

Returns:

(undocumented)

tick
```
public static <T> Source<T,Cancellable> tick(scala.concurrent.duration.FiniteDuration initialDelay,
 scala.concurrent.duration.FiniteDuration interval,
 T tick)
```
Elements are emitted periodically with the specified interval. The tick element will be delivered to downstream consumers that has requested any elements. If a consumer has not requested any elements at the point in time when the tick element is produced it will not receive that tick element later. It will receive new tick elements as soon as it has requested more elements.

Parameters:

initialDelay - (undocumented)

interval - (undocumented)

tick - (undocumented)

Returns:

(undocumented)

single
```
public static <T> Source<T,NotUsed> single(T element)
```
Create a Source with one element. Every connected Sink of this stream will see an individual stream consisting of one element.

Parameters:

element - (undocumented)

Returns:

(undocumented)

repeat
```
public static <T> Source<T,NotUsed> repeat(T element)
```
Create a Source that will continually emit the given element.

Parameters:

element - (undocumented)

Returns:

(undocumented)

unfold

public static <S,E> Source<E,NotUsed> unfold(S s,
                                             scala.Function1<S,scala.Option<scala.Tuple2<S,E>>> f)

Create a Source that will unfold a value of type S into a pair of the next state S and output elements of type E.

For example, all the Fibonacci numbers under 10M:


   Source.unfold(0 → 1) {
    case (a, _) if a > 10000000 ⇒ None
    case (a, b) ⇒ Some((b → (a + b)) → a)
   }

Parameters:: s - (undocumented); f - (undocumented)
Returns:: (undocumented)

unfoldAsync

public static <S,E> Source<E,NotUsed> unfoldAsync(S s,
                                                  scala.Function1<S,scala.concurrent.Future<scala.Option<scala.Tuple2<S,E>>>> f)

Same as unfold, but uses an async function to generate the next state-element tuple.

async fibonacci example:


   Source.unfoldAsync(0 → 1) {
    case (a, _) if a > 10000000 ⇒ Future.successful(None)
    case (a, b) ⇒ Future{
      Thread.sleep(1000)
      Some((b → (a + b)) → a)
    }
   }

Parameters:: s - (undocumented); f - (undocumented)
Returns:: (undocumented)

empty
```
public static <T> Source<T,NotUsed> empty()
```
A Source with no elements, i.e. an empty stream that is completed immediately for every connected Sink.

Returns:

(undocumented)

maybe
```
public static <T> Source<T,scala.concurrent.Promise<scala.Option<T>>> maybe()
```
Create a Source which materializes a Promise which controls what element will be emitted by the Source. If the materialized promise is completed with a Some, that value will be produced downstream, followed by completion. If the materialized promise is completed with a None, no value will be produced downstream and completion will be signalled immediately. If the materialized promise is completed with a failure, then the returned source will terminate with that error. If the downstream of this source cancels before the promise has been completed, then the promise will be completed with None.

Returns:

(undocumented)

failed
```
public static <T> Source<T,NotUsed> failed(java.lang.Throwable cause)
```
Create a Source that immediately ends the stream with the cause error to every connected Sink.

Parameters:

cause - (undocumented)

Returns:

(undocumented)

lazily
```
public static <T,M> Source<T,scala.concurrent.Future<M>> lazily(scala.Function0<Source<T,M>> create)
```
Creates a Source that is not materialized until there is downstream demand, when the source gets materialized the materialized future is completed with its value, if downstream cancels or fails without any demand the create factory is never called and the materialized Future is failed.

Parameters:

create - (undocumented)

Returns:

(undocumented)

asSubscriber
```
public static <T> Source<T,org.reactivestreams.Subscriber<T>> asSubscriber()
```
Creates a Source that is materialized as a Subscriber

Returns:

(undocumented)

actorPublisher
```
public static <T> Source<T,ActorRef> actorPublisher(Props props)
```
Creates a Source that is materialized to an ActorRef which points to an Actor created according to the passed in Props. Actor created by the props must be ActorPublisher.

Parameters:

props - (undocumented)

Returns:

(undocumented)

actorRef
```
public static <T> Source<T,ActorRef> actorRef(int bufferSize,
 OverflowStrategy overflowStrategy)
```
Creates a Source that is materialized as an ActorRef. Messages sent to this actor will be emitted to the stream if there is demand from downstream, otherwise they will be buffered until request for demand is received.
Depending on the defined OverflowStrategy it might drop elements if there is no space available in the buffer.
The strategy akka.stream.OverflowStrategy.backpressure is not supported, and an IllegalArgument("Backpressure overflowStrategy not supported") will be thrown if it is passed as argument.
The buffer can be disabled by using bufferSize of 0 and then received messages are dropped if there is no demand from downstream. When bufferSize is 0 the overflowStrategy does not matter. An async boundary is added after this Source; as such, it is never safe to assume the downstream will always generate demand.
The stream can be completed successfully by sending the actor reference a Status.Success (whose content will be ignored) in which case already buffered elements will be signaled before signaling completion, or by sending PoisonPill in which case completion will be signaled immediately.
The stream can be completed with failure by sending a Status.Failure to the actor reference. In case the Actor is still draining its internal buffer (after having received a Status.Success) before signaling completion and it receives a Status.Failure, the failure will be signaled downstream immediately (instead of the completion signal).
The actor will be stopped when the stream is completed, failed or canceled from downstream, i.e. you can watch it to get notified when that happens.
See also akka.stream.scaladsl.Source.queue.

Parameters:

bufferSize - The size of the buffer in element count

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

Returns:

(undocumented)

zipN

public static <T> Source<scala.collection.immutable.Seq<T>,NotUsed> zipN(scala.collection.immutable.Seq<Source<T,?>> sources)

Combine the elements of multiple streams into a stream of sequences.

Parameters:: sources - (undocumented)
Returns:: (undocumented)

zipWithN

public static <T,O> Source<O,NotUsed> zipWithN(scala.Function1<scala.collection.immutable.Seq<T>,O> zipper,
                                               scala.collection.immutable.Seq<Source<T,?>> sources)

queue
```
public static <T> Source<T,SourceQueueWithComplete<T>> queue(int bufferSize,
 OverflowStrategy overflowStrategy)
```
Creates a Source that is materialized as an SourceQueue. You can push elements to the queue and they will be emitted to the stream if there is demand from downstream, otherwise they will be buffered until request for demand is received. Elements in the buffer will be discarded if downstream is terminated.
Depending on the defined OverflowStrategy it might drop elements if there is no space available in the buffer.
Acknowledgement mechanism is available. akka.stream.scaladsl.SourceQueue.offer returns Future[QueueOfferResult] which completes with QueueOfferResult.Enqueued if element was added to buffer or sent downstream. It completes with QueueOfferResult.Dropped if element was dropped. Can also complete with QueueOfferResult.Failure - when stream failed or QueueOfferResult.QueueClosed when downstream is completed.
The strategy akka.stream.OverflowStrategy.backpressure will not complete last offer():Future call when buffer is full.
You can watch accessibility of stream with akka.stream.scaladsl.SourceQueue.watchCompletion. It returns future that completes with success when stream is completed or fail when stream is failed.
The buffer can be disabled by using bufferSize of 0 and then received message will wait for downstream demand unless there is another message waiting for downstream demand, in that case offer result will be completed according to the overflow strategy.
SourceQueue that current source is materialized to is for single thread usage only.

Parameters:

bufferSize - size of buffer in element count

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

Returns:

(undocumented)

unfoldResource
```
public static <T,S> Source<T,NotUsed> unfoldResource(scala.Function0<S> create,
 scala.Function1<S,scala.Option<T>> read,
 scala.Function1<S,scala.runtime.BoxedUnit> close)
```
Start a new Source from some resource which can be opened, read and closed. Interaction with resource happens in a blocking way.
Example:
```
 Source.unfoldResource(
 () => new BufferedReader(new FileReader("...")),
 reader => Option(reader.readLine()),
 reader => reader.close())
 
```
You can use the supervision strategy to handle exceptions for read function. All exceptions thrown by create or close will fail the stream.
Restart supervision strategy will close and create blocking IO again. Default strategy is Stop which means that stream will be terminated on error in read function by default.
You can configure the default dispatcher for this Source by changing the akka.stream.blocking-io-dispatcher or set it for a given Source by using ActorAttributes.
Parameters:

create - - function that is called on stream start and creates/opens resource.

read - - function that reads data from opened resource. It is called each time backpressure signal is received. Stream calls close and completes when read returns None.

close - - function that closes resource

Returns:

(undocumented)

unfoldResourceAsync
```
public static <T,S> Source<T,NotUsed> unfoldResourceAsync(scala.Function0<scala.concurrent.Future<S>> create,
 scala.Function1<S,scala.concurrent.Future<scala.Option<T>>> read,
 scala.Function1<S,scala.concurrent.Future<Done>> close)
```
Start a new Source from some resource which can be opened, read and closed. It's similar to unfoldResource but takes functions that return Futures instead of plain values.
You can use the supervision strategy to handle exceptions for read function or failures of produced Futures. All exceptions thrown by create or close as well as fails of returned futures will fail the stream.
Restart supervision strategy will close and create resource. Default strategy is Stop which means that stream will be terminated on error in read function (or future) by default.
You can configure the default dispatcher for this Source by changing the akka.stream.blocking-io-dispatcher or set it for a given Source by using ActorAttributes.

Parameters:

create - - function that is called on stream start and creates/opens resource.

read - - function that reads data from opened resource. It is called each time backpressure signal is received. Stream calls close and completes when Future from read function returns None.

close - - function that closes resource

Returns:

(undocumented)

recover

public static <T> FlowOps recover(scala.PartialFunction<java.lang.Throwable,T> pf)

recoverWith

public static <T> FlowOps recoverWith(scala.PartialFunction<java.lang.Throwable,Graph<SourceShape<T>,NotUsed>> pf)

recoverWithRetries

public static <T> FlowOps recoverWithRetries(int attempts,
                                             scala.PartialFunction<java.lang.Throwable,Graph<SourceShape<T>,NotUsed>> pf)

mapError

public static FlowOps mapError(scala.PartialFunction<java.lang.Throwable,java.lang.Throwable> pf)

map

public static <T> FlowOps map(scala.Function1<Out,T> f)

mapConcat

public static <T> FlowOps mapConcat(scala.Function1<Out,scala.collection.immutable.Iterable<T>> f)

statefulMapConcat

public static <T> FlowOps statefulMapConcat(scala.Function0<scala.Function1<Out,scala.collection.immutable.Iterable<T>>> f)

mapAsync

public static <T> FlowOps mapAsync(int parallelism,
                                   scala.Function1<Out,scala.concurrent.Future<T>> f)

mapAsyncUnordered

public static <T> FlowOps mapAsyncUnordered(int parallelism,
                                            scala.Function1<Out,scala.concurrent.Future<T>> f)

filter

public static FlowOps filter(scala.Function1<Out,java.lang.Object> p)

filterNot

public static FlowOps filterNot(scala.Function1<Out,java.lang.Object> p)

takeWhile

public static FlowOps takeWhile(scala.Function1<Out,java.lang.Object> p)

takeWhile

public static FlowOps takeWhile(scala.Function1<Out,java.lang.Object> p,
                                boolean inclusive)

dropWhile

public static FlowOps dropWhile(scala.Function1<Out,java.lang.Object> p)

collect

public static <T> FlowOps collect(scala.PartialFunction<Out,T> pf)

grouped
```
public static FlowOps grouped(int n)
```

limit

public static FlowOps limit(long max)

limitWeighted

public static <T> FlowOps limitWeighted(long max,
                                        scala.Function1<Out,java.lang.Object> costFn)

sliding

public static FlowOps sliding(int n,
                              int step)

scan

public static <T> FlowOps scan(T zero,
                               scala.Function2<T,Out,T> f)

scanAsync

public static <T> FlowOps scanAsync(T zero,
                                    scala.Function2<T,Out,scala.concurrent.Future<T>> f)

fold

public static <T> FlowOps fold(T zero,
                               scala.Function2<T,Out,T> f)

foldAsync

public static <T> FlowOps foldAsync(T zero,
                                    scala.Function2<T,Out,scala.concurrent.Future<T>> f)

reduce

public static <T> FlowOps reduce(scala.Function2<T,T,T> f)

intersperse

public static <T> FlowOps intersperse(T start,
                                      T inject,
                                      T end)

intersperse

public static <T> FlowOps intersperse(T inject)

groupedWithin

public static FlowOps groupedWithin(int n,
                                    scala.concurrent.duration.FiniteDuration d)

delay

public static FlowOps delay(scala.concurrent.duration.FiniteDuration of,
                            DelayOverflowStrategy strategy)

drop
```
public static FlowOps drop(long n)
```

dropWithin

public static FlowOps dropWithin(scala.concurrent.duration.FiniteDuration d)

take
```
public static FlowOps take(long n)
```

takeWithin

public static FlowOps takeWithin(scala.concurrent.duration.FiniteDuration d)

conflateWithSeed

public static <S> FlowOps conflateWithSeed(scala.Function1<Out,S> seed,
                                           scala.Function2<S,Out,S> aggregate)

conflate

public static <O2> FlowOps conflate(scala.Function2<O2,O2,O2> aggregate)

batch

public static <S> FlowOps batch(long max,
                                scala.Function1<Out,S> seed,
                                scala.Function2<S,Out,S> aggregate)

batchWeighted

public static <S> FlowOps batchWeighted(long max,
                                        scala.Function1<Out,java.lang.Object> costFn,
                                        scala.Function1<Out,S> seed,
                                        scala.Function2<S,Out,S> aggregate)

expand

public static <U> FlowOps expand(scala.Function1<Out,scala.collection.Iterator<U>> extrapolate)

buffer

public static FlowOps buffer(int size,
                             OverflowStrategy overflowStrategy)

transform

public static <T> FlowOps transform(scala.Function0<Stage<Out,T>> mkStage)

prefixAndTail

public static <U> FlowOps prefixAndTail(int n)

groupBy

public static <K> SubFlow<Out,Mat,FlowOps,java.lang.Object> groupBy(int maxSubstreams,
                                                                    scala.Function1<Out,K> f)

splitWhen

public static SubFlow<Out,Mat,FlowOps,java.lang.Object> splitWhen(SubstreamCancelStrategy substreamCancelStrategy,
                                                                  scala.Function1<Out,java.lang.Object> p)

splitWhen

public static SubFlow<Out,Mat,FlowOps,java.lang.Object> splitWhen(scala.Function1<Out,java.lang.Object> p)

splitAfter

public static SubFlow<Out,Mat,FlowOps,java.lang.Object> splitAfter(SubstreamCancelStrategy substreamCancelStrategy,
                                                                   scala.Function1<Out,java.lang.Object> p)

splitAfter

public static SubFlow<Out,Mat,FlowOps,java.lang.Object> splitAfter(scala.Function1<Out,java.lang.Object> p)

flatMapConcat

public static <T,M> FlowOps flatMapConcat(scala.Function1<Out,Graph<SourceShape<T>,M>> f)

flatMapMerge

public static <T,M> FlowOps flatMapMerge(int breadth,
                                         scala.Function1<Out,Graph<SourceShape<T>,M>> f)

initialTimeout

public static FlowOps initialTimeout(scala.concurrent.duration.FiniteDuration timeout)

completionTimeout

public static FlowOps completionTimeout(scala.concurrent.duration.FiniteDuration timeout)

idleTimeout

public static FlowOps idleTimeout(scala.concurrent.duration.FiniteDuration timeout)

backpressureTimeout

public static FlowOps backpressureTimeout(scala.concurrent.duration.FiniteDuration timeout)

keepAlive

public static <U> FlowOps keepAlive(scala.concurrent.duration.FiniteDuration maxIdle,
                                    scala.Function0<U> injectedElem)

throttle

public static FlowOps throttle(int elements,
                               scala.concurrent.duration.FiniteDuration per,
                               int maximumBurst,
                               ThrottleMode mode)

throttle

public static FlowOps throttle(int cost,
                               scala.concurrent.duration.FiniteDuration per,
                               int maximumBurst,
                               scala.Function1<Out,java.lang.Object> costCalculation,
                               ThrottleMode mode)

detach
```
public static FlowOps detach()
```

initialDelay

public static FlowOps initialDelay(scala.concurrent.duration.FiniteDuration delay)

log

public static FlowOps log(java.lang.String name,
                          scala.Function1<Out,java.lang.Object> extract,
                          LoggingAdapter log)

zip

public static <U> FlowOps zip(Graph<SourceShape<U>,?> that)

zipGraph

protected static <U,M> Graph<FlowShape<Out,scala.Tuple2<Out,U>>,M> zipGraph(Graph<SourceShape<U>,M> that)

zipWith

public static <Out2,Out3> FlowOps zipWith(Graph<SourceShape<Out2>,?> that,
                                          scala.Function2<Out,Out2,Out3> combine)

zipWithGraph

protected static <Out2,Out3,M> Graph<FlowShape<Out,Out3>,M> zipWithGraph(Graph<SourceShape<Out2>,M> that,
                                                                         scala.Function2<Out,Out2,Out3> combine)

zipWithIndex
```
public static FlowOps zipWithIndex()
```

interleave

public static <U> FlowOps interleave(Graph<SourceShape<U>,?> that,
                                     int segmentSize)

interleaveGraph

protected static <U,M> Graph<FlowShape<Out,U>,M> interleaveGraph(Graph<SourceShape<U>,M> that,
                                                                 int segmentSize)

merge

public static <U,M> FlowOps merge(Graph<SourceShape<U>,M> that,
                                  boolean eagerComplete)

mergeGraph

protected static <U,M> Graph<FlowShape<Out,U>,M> mergeGraph(Graph<SourceShape<U>,M> that,
                                                            boolean eagerComplete)

mergeSorted

public static <U,M> FlowOps mergeSorted(Graph<SourceShape<U>,M> that,
                                        scala.math.Ordering<U> ord)

mergeSortedGraph

protected static <U,M> Graph<FlowShape<Out,U>,M> mergeSortedGraph(Graph<SourceShape<U>,M> that,
                                                                  scala.math.Ordering<U> ord)

concat

public static <U,Mat2> FlowOps concat(Graph<SourceShape<U>,Mat2> that)

concatGraph

protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2> concatGraph(Graph<SourceShape<U>,Mat2> that)

prepend

public static <U,Mat2> FlowOps prepend(Graph<SourceShape<U>,Mat2> that)

prependGraph

protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2> prependGraph(Graph<SourceShape<U>,Mat2> that)

orElse

public static <U,Mat2> FlowOps orElse(Graph<SourceShape<U>,Mat2> secondary)

orElseGraph

protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2> orElseGraph(Graph<SourceShape<U>,Mat2> secondary)

$plus$plus

public static <U,M> FlowOps $plus$plus(Graph<SourceShape<U>,M> that)

alsoTo

public static FlowOps alsoTo(Graph<SinkShape<Out>,?> that)

alsoToGraph

protected static <M> Graph<FlowShape<Out,Out>,M> alsoToGraph(Graph<SinkShape<Out>,M> that)

andThen

public static <T> FlowOps andThen(Stages.SymbolicStage<Out,T> op)

sliding$default$2
```
public static int sliding$default$2()
```

delay$default$2

public static DelayOverflowStrategy delay$default$2()

merge$default$2

public static <U,M> boolean merge$default$2()

log$default$2

public static scala.Function1<Out,java.lang.Object> log$default$2()

log$default$3

public static LoggingAdapter log$default$3(java.lang.String name,
                                           scala.Function1<Out,java.lang.Object> extract)

zipMat

public static <U,Mat2,Mat3> FlowOpsMat zipMat(Graph<SourceShape<U>,Mat2> that,
                                              scala.Function2<Mat,Mat2,Mat3> matF)

zipWithMat

public static <Out2,Out3,Mat2,Mat3> FlowOpsMat zipWithMat(Graph<SourceShape<Out2>,Mat2> that,
                                                          scala.Function2<Out,Out2,Out3> combine,
                                                          scala.Function2<Mat,Mat2,Mat3> matF)

mergeMat

public static <U,Mat2,Mat3> FlowOpsMat mergeMat(Graph<SourceShape<U>,Mat2> that,
                                                boolean eagerComplete,
                                                scala.Function2<Mat,Mat2,Mat3> matF)

interleaveMat

public static <U,Mat2,Mat3> FlowOpsMat interleaveMat(Graph<SourceShape<U>,Mat2> that,
                                                     int request,
                                                     scala.Function2<Mat,Mat2,Mat3> matF)

mergeSortedMat

public static <U,Mat2,Mat3> FlowOpsMat mergeSortedMat(Graph<SourceShape<U>,Mat2> that,
                                                      scala.Function2<Mat,Mat2,Mat3> matF,
                                                      scala.math.Ordering<U> ord)

concatMat

public static <U,Mat2,Mat3> FlowOpsMat concatMat(Graph<SourceShape<U>,Mat2> that,
                                                 scala.Function2<Mat,Mat2,Mat3> matF)

prependMat

public static <U,Mat2,Mat3> FlowOpsMat prependMat(Graph<SourceShape<U>,Mat2> that,
                                                  scala.Function2<Mat,Mat2,Mat3> matF)

orElseMat

public static <U,Mat2,Mat3> FlowOpsMat orElseMat(Graph<SourceShape<U>,Mat2> secondary,
                                                 scala.Function2<Mat,Mat2,Mat3> matF)

alsoToMat

public static <Mat2,Mat3> FlowOpsMat alsoToMat(Graph<SinkShape<Out>,Mat2> that,
                                               scala.Function2<Mat,Mat2,Mat3> matF)

watchTermination

public static <Mat2> FlowOpsMat watchTermination(scala.Function2<Mat,scala.concurrent.Future<Done>,Mat2> matF)

monitor

public static <Mat2> FlowOpsMat monitor(scala.Function2<Mat,FlowMonitor<Out>,Mat2> combine)

transformMaterializing

public static <T,M> FlowOpsMat transformMaterializing(scala.Function0<scala.Tuple2<Stage<Out,T>,M>> mkStageAndMaterialized)

mergeMat$default$2

public static <U,Mat2,Mat3> boolean mergeMat$default$2()

module
```
public StreamLayout.Module module()
```
Description copied from interface: Graph

INTERNAL API.
Every materializable element must be backed by a stream layout module

Specified by:

module in interface Graph<SourceShape<Out>,Mat>

Returns:

(undocumented)

shape
```
public SourceShape<Out> shape()
```
Description copied from interface: Graph

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

Specified by:

shape in interface Graph<SourceShape<Out>,Mat>

Returns:

(undocumented)

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

via

public <T,Mat2> Source<T,Mat> via(Graph<FlowShape<Out,T>,Mat2> flow)

Specified by:: via in interface FlowOps<Out,Mat>

viaMat
```
public <T,Mat2,Mat3> Source<T,Mat3> viaMat(Graph<FlowShape<Out,T>,Mat2> flow,
 scala.Function2<Mat,Mat2,Mat3> combine)
```
Description copied from interface: FlowOpsMat
Transform this Flow by appending the given processing steps.
```
 +----------------------------+
 | Resulting Flow |
 | |
 | +------+ +------+ |
 | | | | | |
 In ~~> | this | ~Out~> | flow | ~~> T
 | | | | | |
 | +------+ +------+ |
 +----------------------------+
 
```
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.
Specified by:

viaMat in interface FlowOpsMat<Out,Mat>

Parameters:

flow - (undocumented)

combine - (undocumented)

Returns:

(undocumented)

to
```
public <Mat2> RunnableGraph<Mat> to(Graph<SinkShape<Out>,Mat2> sink)
```
Connect this Source to a Sink, concatenating the processing steps of both.

Specified by:

to in interface FlowOps<Out,Mat>

Parameters:

sink - (undocumented)

Returns:

(undocumented)

toMat
```
public <Mat2,Mat3> RunnableGraph<Mat3> toMat(Graph<SinkShape<Out>,Mat2> sink,
 scala.Function2<Mat,Mat2,Mat3> combine)
```
Connect this Source to a Sink, concatenating the processing steps of both.

Specified by:

toMat in interface FlowOpsMat<Out,Mat>

Parameters:

sink - (undocumented)

combine - (undocumented)

Returns:

(undocumented)

mapMaterializedValue
```
public <Mat2> Source<Out,Mat2> mapMaterializedValue(scala.Function1<Mat,Mat2> f)
```
Transform only the materialized value of this Source, leaving all other properties as they were.

Specified by:

mapMaterializedValue in interface FlowOpsMat<Out,Mat>

Parameters:

f - (undocumented)

Returns:

(undocumented)

runWith
```
public <Mat2> Mat2 runWith(Graph<SinkShape<Out>,Mat2> sink,
 Materializer materializer)
```
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.

Parameters:

sink - (undocumented)

materializer - (undocumented)

Returns:

(undocumented)

runFold
```
public  scala.concurrent.Future runFold(U zero,
 scala.Function2<U,Out,U> f,
 Materializer materializer)
```
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 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.

Parameters:

zero - (undocumented)

f - (undocumented)

materializer - (undocumented)

Returns:

(undocumented)

runFoldAsync
```
public  scala.concurrent.Future runFoldAsync(U zero,
 scala.Function2<U,Out,scala.concurrent.Future> f,
 Materializer materializer)
```
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 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.

Parameters:

zero - (undocumented)

f - (undocumented)

materializer - (undocumented)

Returns:

(undocumented)

runReduce
```
public  scala.concurrent.Future runReduce(scala.Function2<U,U,U> f,
 Materializer materializer)
```
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 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 stage will fail its downstream with a NoSuchElementException, which is semantically in-line with that Scala's standard library collections do in such situations.

Parameters:

f - (undocumented)

materializer - (undocumented)

Returns:

(undocumented)

runForeach
```
public scala.concurrent.Future<Done> runForeach(scala.Function1<Out,scala.runtime.BoxedUnit> f,
 Materializer materializer)
```
Shortcut for running this Source with a foreach procedure. The given procedure is invoked for each received element. The returned 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.

Parameters:

f - (undocumented)

materializer - (undocumented)

Returns:

(undocumented)

withAttributes
```
public Source<Out,Mat> withAttributes(Attributes attr)
```
Change the attributes of this Source to the given ones and seal the list of attributes. This means that further calls will not be able to remove these attributes, but instead add new ones. Note that this operation has no effect on an empty Flow (because the attributes apply only to the contained processing stages).

Specified by:

withAttributes in interface Graph<SourceShape<Out>,Mat>

Specified by:

withAttributes in interface FlowOps<Out,Mat>

Parameters:

attr - (undocumented)

Returns:

(undocumented)

addAttributes
```
public Source<Out,Mat> addAttributes(Attributes attr)
```
Add the given attributes to this Source. Further calls to withAttributes will not remove these attributes. Note that this operation has no effect on an empty Flow (because the attributes apply only to the contained processing stages).

Specified by:

addAttributes in interface Graph<SourceShape<Out>,Mat>

Specified by:

addAttributes in interface FlowOps<Out,Mat>

Parameters:

attr - (undocumented)

Returns:

(undocumented)

named
```
public Source<Out,Mat> named(java.lang.String name)
```
Add a name attribute to this Source.

Specified by:

named in interface Graph<SourceShape<Out>,Mat>

Specified by:

named in interface FlowOps<Out,Mat>

Parameters:

name - (undocumented)

Returns:

(undocumented)

async
```
public Source<Out,Mat> async()
```
Put an asynchronous boundary around this Source

Specified by:

async in interface Graph<SourceShape<Out>,Mat>

Specified by:

async in interface FlowOps<Out,Mat>

Returns:

(undocumented)

asJava
```
public Source<Out,Mat> asJava()
```
Converts this Scala DSL element to it's Java DSL counterpart.

Returns:

(undocumented)

combine

public <T,U> Source<U,NotUsed> combine(Source<T,?> first,
                                       Source<T,?> second,
                                       scala.collection.Seq<Source<T,?>> rest,
                                       scala.Function1<java.lang.Object,Graph<UniformFanInShape<T,U>,NotUsed>> strategy)

Combines several sources with fun-in strategy like Merge or Concat and returns Source.

Parameters:: first - (undocumented); second - (undocumented); rest - (undocumented); strategy - (undocumented)
Returns:: (undocumented)

Class Source<Out,Mat>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface akka.stream.scaladsl.FlowOpsMat

Methods inherited from interface akka.stream.scaladsl.FlowOps

Constructor Detail

Source

Method Detail

fromPublisher

fromIterator

cycle

fromGraph

apply

fromFuture

fromCompletionStage

tick

single

repeat

unfold

unfoldAsync

empty

maybe

failed

lazily

asSubscriber

actorPublisher

actorRef

zipN

zipWithN

queue

unfoldResource

unfoldResourceAsync

recover

recoverWith

recoverWithRetries

mapError

map

mapConcat

statefulMapConcat

mapAsync

mapAsyncUnordered

filter

filterNot

takeWhile

takeWhile

dropWhile

collect

grouped

limit

limitWeighted

sliding

scan

scanAsync

fold

foldAsync

reduce

intersperse

intersperse

groupedWithin

delay

drop

dropWithin

take

takeWithin

conflateWithSeed

conflate

batch

batchWeighted

expand

buffer

transform

prefixAndTail

groupBy

splitWhen

splitWhen

splitAfter

splitAfter

flatMapConcat

flatMapMerge