Class

EventLoopFutureQueue

Allows you to queue closures that produce an EventLoopFuture, so each future only gets run if the previous ones complete, succeed, or fail.

final class EventLoopFutureQueue

Topics

Initializers

init(eventLoop: any EventLoop)
Create a new EventLoopFutureQueue on a given event loop.

Instance Properties

let eventLoop: any EventLoop
The event loop that all the futures’s completions are handled on.

Instance Methods

func append<Value>(@autoclosure () -> EventLoopFuture<Value>, runningOn: EventLoopFutureQueue.ContinueCondition) -> EventLoopFuture<Value>
An overload for append(generator:runningOn:) that takes in an EventLoopFuture as an auto closure to provide a better 1-liner API.
func append(each:_:)
For each element of the provided collection, invoke the given generator and queue the returned future. Return a future whose value is an array containing the result of each generated future in the same order as the original sequence. The resulting array is intended to have semantics substantially similar to those provided by EventLoop.flatten(_:on:).
func append<Value>(onPrevious: EventLoopFutureQueue.ContinueCondition, generator: () -> EventLoopFuture<Value>) -> EventLoopFuture<Value>
Adds another EventLoopFuture producing closure to be run as soon as all previously queued future have completed, succeeded, or failed.

Enumerations

enum ContinueCondition
Under what conditions an appended closure should be run.
enum ContinueError
Errors that get propogated based on a future’s completion status and the next appended closure’s continuation condition.

See Also

EventLoopFuture

func mapEach<Result>(KeyPath<Value.Element, Result>) -> EventLoopFuture<[Result]>
Gets the value of a key path for each element in the sequence that is wrapped by an EventLoopFuture.
func mapEach<Result>((Value.Element) -> Result) -> EventLoopFuture<[Result]>
Calls a closure on each element in the sequence that is wrapped by an EventLoopFuture.
func mapEachCompact<Result>(KeyPath<Value.Element, Result?>) -> EventLoopFuture<[Result]>
Gets the optional value of a key path for each element in the sequence that is wrapped by an EventLoopFuture.
func mapEachCompact<Result>((Value.Element) -> Result?) -> EventLoopFuture<[Result]>
Calls a closure, which returns an Optional, on each element in the sequence that is wrapped by an EventLoopFuture.
func mapEachFlat<ResultSegment>(KeyPath<Value.Element, ResultSegment>) -> EventLoopFuture<[ResultSegment.Element]>
Gets the collection value of a key path for each element in the sequence that is wrapped by an EventLoopFuture, combining the results into a single result collection.
func mapEachFlat<ResultSegment>((Value.Element) -> ResultSegment) -> EventLoopFuture<[ResultSegment.Element]>
Calls a closure which returns a collection on each element in the sequence that is wrapped by an EventLoopFuture, combining the results into a single result collection.
func flatMapEach(on: any EventLoop, (Value.Element) -> EventLoopFuture<Void>) -> EventLoopFuture<Void>
Calls a closure, which returns an EventLoopFuture, on each element in a sequence that is wrapped by an EventLoopFuture. No results from each future are expected.
func flatMapEach<Result>(on: any EventLoop, (Value.Element) -> EventLoopFuture<Result>) -> EventLoopFuture<[Result]>
Calls a closure, which returns an EventLoopFuture, on each element in a sequence that is wrapped by an EventLoopFuture.
func flatMapEachCompact<Result>(on: any EventLoop, (Value.Element) -> EventLoopFuture<Result?>) -> EventLoopFuture<[Result]>
Calls a closure, which returns an EventLoopFuture<Optional>, on each element in a sequence that is wrapped by an EventLoopFuture.
func flatMapEachThrowing<Result>((Value.Element) throws -> Result) -> EventLoopFuture<[Result]>
Calls a closure on each element in the sequence that is wrapped by an EventLoopFuture.
func flatMapEachCompactThrowing<Result>((Value.Element) throws -> Result?) -> EventLoopFuture<[Result]>
Calls a closure, which returns an Optional, on each element in the sequence that is wrapped by an EventLoopFuture.
func sequencedFlatMapEach((Value.Element) -> EventLoopFuture<Void>) -> EventLoopFuture<Void>
An overload of sequencedFlatMapEach(_:) which returns a Void future instead of [Void] when the result type of the transform closure is Void.
func sequencedFlatMapEach<Result>((Value.Element) -> EventLoopFuture<Result>) -> EventLoopFuture<[Result]>
A variant form of flatMapEach(on:_:) which guarantees:
func sequencedFlatMapEachCompact<Result>((Value.Element) -> EventLoopFuture<Result?>) -> EventLoopFuture<[Result]>
Variant of sequencedFlatMapEach(_:) which provides compactMap() semantics by allowing result values to be nil. Such results are not included in the output array.
static func whenTheySucceed<A, B>(EventLoopFuture<A>, EventLoopFuture<B>, file: StaticString, line: UInt) -> EventLoopFuture<(A, B)>
Returns a new EventLoopFuture that succeeds only if all of the provided fs succeed. The new EventLoopFuture will contain all of the values fulfilled by the fs.