Creates a Source that is materialized as an akka.actor.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 akka.stream.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 akka.actor.Status.Success (whose content will be ignored) in which case already buffered elements will be signaled before signaling completion.

The stream can be completed with failure by sending a akka.actor.Status.Failure to the actor reference. In case the Actor is still draining its internal buffer (after having received a akka.actor.Status.Success) before signaling completion and it receives a akka.actor.Status.Failure, the failure will be signaled downstream immediately (instead of the completion signal).

Note that terminating the actor without first completing it, either with a success or a failure, will prevent the actor triggering downstream completion and the stream will continue to run even though the source actor is dead. Therefore you should **not** attempt to manually terminate the actor such as with a akka.actor.PoisonPill.

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.javadsl.Source.queue.

Helper to create 'cycled' Source from iterator provider. Example usage:

Source.cycle(() -> Arrays.asList(1, 2, 3).iterator());

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.

Create a Source with no elements. The result is the same as calling Source.<O>empty()

Create a Source with no elements, i.e. an empty stream that is completed immediately for every connected Sink.

Helper to create Source from Iterable. Example usage:

List<Integer> data = new ArrayList<Integer>();
data.add(1);
data.add(2);
data.add(3);
Source.from(data);

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.

Make sure that the Iterable is immutable or at least not modified after being used as a Source. Otherwise the stream may fail with ConcurrentModificationException or other more subtle errors may occur.

Starts a new Source from the given CompletionStage. The stream will consist of one element when the CompletionStage is completed with a successful value, which may happen before or after materializing the Flow. The stream terminates with a failure if the CompletionStage is completed with a failure.

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.

Streams the elements of the given future source once it successfully completes. If the Future fails the stream is failed with the exception from the future. If downstream cancels before the stream completes the materialized Future will be failed with a StreamDetachedException.

Helper to create Source from Iterator. Example usage:

List<Integer> data = new ArrayList<Integer>();
data.add(1);
data.add(2);
data.add(3);
Source.from(() -> data.iterator());

Start a new Source from the given Iterator. 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.

Helper to create Source from Publisher.

Construct a transformation starting with given publisher. The transformation steps are executed by a series of org.reactivestreams.Processor instances that mediate the flow of elements downstream and the propagation of back-pressure upstream.

Streams the elements of an asynchronous source once its given CompletionStage completes. If the CompletionStage fails the stream is failed with the exception from the future. If downstream cancels before the stream completes the materialized CompletionStage will be failed with a StreamDetachedException

Creates a Source from supplied future factory that is not called until downstream demand. When source gets materialized the materialized future is completed with the value from the factory. If downstream cancels or fails without any demand the create factory is never called and the materialized Future is failed.

Create a Source which materializes a java.util.concurrent.CompletableFuture which controls what element will be emitted by the Source. If the materialized promise is completed with a filled Optional, that value will be produced downstream, followed by completion. If the materialized promise is completed with an empty Optional, 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 an empty Optional.

Creates a Source that is materialized as an akka.stream.javadsl.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 akka.stream.OverflowStrategy it might drop elements if there is no space available in the buffer.

Acknowledgement mechanism is available. akka.stream.javadsl.SourceQueue.offer returns CompletionStage<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():CompletionStage call when buffer is full.

You can watch accessibility of stream with akka.stream.javadsl.SourceQueue.watchCompletion. It returns a future that completes with success when this operator is completed or fails 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.

Creates Source that represents integer values in range [start;end], with the given step. It allows to create Source out of range as simply as on Scala Source(1 to N)

Uses Int, Int) internally

Creates Source that represents integer values in range [start;end], step equals to 1. It allows to create Source out of range as simply as on Scala Source(1 to N)

Uses Int) internally

Create a Source with one element. Every connected Sink of this stream will see an individual stream consisting of one element.

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.

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 -> 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.materializer.blocking-io-dispatcher or set it for a given Source by using ActorAttributes.

Adheres to the ActorAttributes.SupervisionStrategy attribute.

Start a new Source from some resource which can be opened, read and closed. It's similar to unfoldResource but takes functions that return CompletionStage 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.materializer.blocking-io-dispatcher or set it for a given Source by using ActorAttributes.

Adheres to the ActorAttributes.SupervisionStrategy attribute.

Upcast a stream of elements to a stream of supertypes of that element. Useful in combination with fan-in operators where you do not want to pay the cost of casting each element in a map.

Example:

Source<Apple, NotUsed> apples = Source.single(new Apple());
Source<Orange, NotUsed> oranges = Source.single(new Orange());
Source<Fruit, NotUsed> appleFruits = Source.upcast(apples);
Source<Fruit, NotUsed> orangeFruits = Source.upcast(oranges);

Source<Fruit, NotUsed> fruits = appleFruits.merge(orangeFruits);

Creates a Source that is materialized to an akka.actor.ActorRef which points to an Actor created according to the passed in akka.actor.Props. Actor created by the props should be akka.stream.actor.ActorPublisher.

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.