mirror of
https://github.com/apple/swift-async-algorithms
synced 2026-11-22 04:10:40 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9cfed92b02 | ||
|
|
ca2ac60495 | ||
|
|
bf0ec24bde | ||
|
|
0ebc8058fc | ||
|
|
a07a3f41b5 | ||
|
|
e7b9b6039d | ||
|
|
3f12423c47 |
No files matched your search
@@ -1,16 +1,16 @@
|
||||
# AsyncLazySequence
|
||||
# AsyncSyncSequence
|
||||
|
||||
* Proposal: [NNNN](NNNN-lazy.md)
|
||||
* Authors: [Philippe Hausler](https://github.com/phausler)
|
||||
* Status: **Implemented**
|
||||
|
||||
* Implementation:
|
||||
[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncLazySequence.swift) |
|
||||
[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncSyncSequence.swift) |
|
||||
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestLazy.swift)
|
||||
|
||||
## Introduction
|
||||
|
||||
`AsyncLazySequence` converts a non-asynchronous sequence into an asynchronous one.
|
||||
`AsyncSyncSequence` converts a non-asynchronous sequence into an asynchronous one.
|
||||
|
||||
This operation is available for all `Sequence` types.
|
||||
|
||||
@@ -22,19 +22,19 @@ let characters = "abcde".async
|
||||
This transformation can be useful to test operations specifically available on `AsyncSequence` but also is useful
|
||||
to combine with other `AsyncSequence` types to provide well known sources of data.
|
||||
|
||||
The `.async` property returns an `AsyncLazySequence` that is generic upon the base `Sequence` it was constructed from.
|
||||
The `.async` property returns an `AsyncSyncSequence` that is generic upon the base `Sequence` it was constructed from.
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
public var async: AsyncLazySequence<Self> { get }
|
||||
public var async: AsyncSyncSequence<Self> { get }
|
||||
}
|
||||
|
||||
public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
|
||||
public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {
|
||||
...
|
||||
}
|
||||
|
||||
extension AsyncLazySequence: Sendable where Base: Sendable { }
|
||||
extension AsyncLazySequence.Iterator: Sendable where Base.Iterator: Sendable { }
|
||||
extension AsyncSyncSequence: Sendable where Base: Sendable { }
|
||||
extension AsyncSyncSequence.Iterator: Sendable where Base.Iterator: Sendable { }
|
||||
```
|
||||
|
||||
### Naming
|
||||
@@ -45,4 +45,4 @@ succinct name in inspiration from `.lazy`, and the type is named in reference to
|
||||
|
||||
## Effect on API resilience
|
||||
|
||||
`AsyncLazySequence` has a trivial implementation and is marked as `@frozen` and `@inlinable`. This removes the ability of this type and functions to be ABI resilient boundaries at the benefit of being highly optimizable.
|
||||
`AsyncSyncSequence` has a trivial implementation and is marked as `@frozen` and `@inlinable`. This removes the ability of this type and functions to be ABI resilient boundaries at the benefit of being highly optimizable.
|
||||
@@ -34,8 +34,8 @@
|
||||
| `AsyncInterspersedSequence.Iterator` | rethrows | Not Sendable|
|
||||
| `AsyncJoinedSequence` | rethrows | Conditional |
|
||||
| `AsyncJoinedSequence.Iterator` | rethrows | Not Sendable|
|
||||
| `AsyncLazySequence` | non-throwing | Conditional |
|
||||
| `AsyncLazySequence.Iterator` | non-throwing | Not Sendable|
|
||||
| `AsyncSyncSequence` | non-throwing | Conditional |
|
||||
| `AsyncSyncSequence.Iterator` | non-throwing | Not Sendable|
|
||||
| `AsyncLimitBuffer` | non-throwing | Sendable |
|
||||
| `AsyncMerge2Sequence` | rethrows | Sendable |
|
||||
| `AsyncMerge2Sequence.Iterator` | rethrows | Not Sendable|
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# AsyncLazySequence
|
||||
# AsyncSyncSequence
|
||||
|
||||
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncLazySequence.swift) |
|
||||
[[Source](https://github.com/apple/swift-async-algorithms/blob/main/Sources/AsyncAlgorithms/AsyncSyncSequence.swift) |
|
||||
[Tests](https://github.com/apple/swift-async-algorithms/blob/main/Tests/AsyncAlgorithmsTests/TestLazy.swift)]
|
||||
|
||||
Converts a non-asynchronous sequence into an asynchronous one.
|
||||
@@ -17,19 +17,19 @@ to combine with other `AsyncSequence` types to provide well known sources of dat
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `.async` property returns an `AsyncLazySequence` that is generic upon the base `Sequence` it was constructed from.
|
||||
The `.async` property returns an `AsyncSyncSequence` that is generic upon the base `Sequence` it was constructed from.
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
public var async: AsyncLazySequence<Self> { get }
|
||||
public var async: AsyncSyncSequence<Self> { get }
|
||||
}
|
||||
|
||||
public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
|
||||
public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {
|
||||
...
|
||||
}
|
||||
|
||||
extension AsyncLazySequence: Sendable where Base: Sendable { }
|
||||
extension AsyncLazySequence.Iterator: Sendable where Base.Iterator: Sendable { }
|
||||
extension AsyncSyncSequence: Sendable where Base: Sendable { }
|
||||
extension AsyncSyncSequence.Iterator: Sendable where Base.Iterator: Sendable { }
|
||||
```
|
||||
|
||||
### Naming
|
||||
|
||||
@@ -1,308 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
actor AsyncBufferState<Input: Sendable, Output: Sendable> {
|
||||
enum TerminationState: Sendable, CustomStringConvertible {
|
||||
case running
|
||||
case baseFailure(Error) // An error from the base sequence has occurred. We need to process any buffered items before throwing the error. We can rely on it not emitting any more items.
|
||||
case baseTermination
|
||||
case terminal
|
||||
|
||||
var description: String {
|
||||
switch self {
|
||||
case .running: return "running"
|
||||
case .baseFailure: return "base failure"
|
||||
case .baseTermination: return "base termination"
|
||||
case .terminal: return "terminal"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var pending = [UnsafeContinuation<Result<Output?, Error>, Never>]()
|
||||
var terminationState = TerminationState.running
|
||||
|
||||
init() { }
|
||||
|
||||
func drain<Buffer: AsyncBuffer>(buffer: Buffer) async where Buffer.Input == Input, Buffer.Output == Output {
|
||||
guard pending.count > 0 else {
|
||||
return
|
||||
}
|
||||
|
||||
do {
|
||||
if let value = try await buffer.pop() {
|
||||
pending.removeFirst().resume(returning: .success(value))
|
||||
} else {
|
||||
switch terminationState {
|
||||
case .running:
|
||||
// There's no value to report, because it was probably grabbed by next() before we could grab it. The pending continuation was either resumed by next() directly, or will be by a future enqueued value or base termination/failure.
|
||||
break
|
||||
case .baseFailure(let error):
|
||||
// Now that there are no more items in the buffer, we can finally report the base sequence's error and enter terminal state.
|
||||
pending.removeFirst().resume(returning: .failure(error))
|
||||
self.terminate()
|
||||
case .terminal, .baseTermination:
|
||||
self.terminate()
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// Errors thrown by the buffer immediately terminate the sequence.
|
||||
pending.removeFirst().resume(returning: .failure(error))
|
||||
self.terminate()
|
||||
}
|
||||
}
|
||||
|
||||
func enqueue<Buffer: AsyncBuffer>(_ item: Input, buffer: Buffer) async where Buffer.Input == Input, Buffer.Output == Output {
|
||||
await buffer.push(item)
|
||||
await drain(buffer: buffer)
|
||||
}
|
||||
|
||||
func fail<Buffer: AsyncBuffer>(_ error: Error, buffer: Buffer) async where Buffer.Input == Input, Buffer.Output == Output {
|
||||
terminationState = .baseFailure(error)
|
||||
await drain(buffer: buffer)
|
||||
}
|
||||
|
||||
func finish<Buffer: AsyncBuffer>(buffer: Buffer) async where Buffer.Input == Input, Buffer.Output == Output {
|
||||
if case .running = terminationState {
|
||||
terminationState = .baseTermination
|
||||
}
|
||||
await drain(buffer: buffer)
|
||||
}
|
||||
|
||||
func terminate() {
|
||||
terminationState = .terminal
|
||||
let oldPending = pending
|
||||
pending = []
|
||||
for continuation in oldPending {
|
||||
continuation.resume(returning: .success(nil))
|
||||
}
|
||||
}
|
||||
|
||||
func next<Buffer: AsyncBuffer>(buffer: Buffer) async throws -> Buffer.Output? where Buffer.Input == Input, Buffer.Output == Output {
|
||||
if case .terminal = terminationState {
|
||||
return nil
|
||||
}
|
||||
|
||||
do {
|
||||
while let value = try await buffer.pop() {
|
||||
if let continuation = pending.first {
|
||||
pending.removeFirst()
|
||||
continuation.resume(returning: .success(value))
|
||||
} else {
|
||||
return value
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// Errors thrown by the buffer immediately terminate the sequence.
|
||||
self.terminate()
|
||||
throw error
|
||||
}
|
||||
|
||||
switch terminationState {
|
||||
case .running:
|
||||
break
|
||||
case .baseFailure(let error):
|
||||
self.terminate()
|
||||
throw error
|
||||
case .baseTermination, .terminal:
|
||||
self.terminate()
|
||||
return nil
|
||||
}
|
||||
|
||||
let result: Result<Output?, Error> = await withUnsafeContinuation { continuation in
|
||||
pending.append(continuation)
|
||||
}
|
||||
return try result._rethrowGet()
|
||||
}
|
||||
}
|
||||
|
||||
/// An asynchronous buffer storage actor protocol used for buffering
|
||||
/// elements to an `AsyncBufferSequence`.
|
||||
@rethrows
|
||||
public protocol AsyncBuffer: Actor {
|
||||
associatedtype Input: Sendable
|
||||
associatedtype Output: Sendable
|
||||
|
||||
/// Push an element to enqueue to the buffer
|
||||
func push(_ element: Input) async
|
||||
|
||||
/// Pop an element from the buffer.
|
||||
///
|
||||
/// Implementors of `pop()` may throw. In cases where types
|
||||
/// throw from this function, that throwing behavior contributes to
|
||||
/// the rethrowing characteristics of `AsyncBufferSequence`.
|
||||
func pop() async throws -> Output?
|
||||
}
|
||||
|
||||
/// A buffer that limits pushed items by a certain count.
|
||||
public actor AsyncLimitBuffer<Element: Sendable>: AsyncBuffer {
|
||||
/// A policy for buffering elements to an `AsyncLimitBuffer`
|
||||
public enum Policy: Sendable {
|
||||
/// A policy for no bounding limit of pushed elements.
|
||||
case unbounded
|
||||
/// A policy for limiting to a specific number of oldest values.
|
||||
case bufferingOldest(Int)
|
||||
/// A policy for limiting to a specific number of newest values.
|
||||
case bufferingNewest(Int)
|
||||
}
|
||||
|
||||
var buffer = [Element]()
|
||||
let policy: Policy
|
||||
|
||||
init(policy: Policy) {
|
||||
// limits should always be greater than 0 items
|
||||
switch policy {
|
||||
case .bufferingNewest(let limit):
|
||||
precondition(limit > 0)
|
||||
case .bufferingOldest(let limit):
|
||||
precondition(limit > 0)
|
||||
default: break
|
||||
}
|
||||
self.policy = policy
|
||||
}
|
||||
|
||||
/// Push an element to enqueue to the buffer.
|
||||
public func push(_ element: Element) async {
|
||||
switch policy {
|
||||
case .unbounded:
|
||||
buffer.append(element)
|
||||
case .bufferingOldest(let limit):
|
||||
if buffer.count < limit {
|
||||
buffer.append(element)
|
||||
}
|
||||
case .bufferingNewest(let limit):
|
||||
if buffer.count < limit {
|
||||
// there is space available
|
||||
buffer.append(element)
|
||||
} else {
|
||||
// no space is available and this should make some room
|
||||
buffer.removeFirst()
|
||||
buffer.append(element)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Pop an element from the buffer.
|
||||
public func pop() async -> Element? {
|
||||
guard buffer.count > 0 else {
|
||||
return nil
|
||||
}
|
||||
return buffer.removeFirst()
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncSequence where Element: Sendable, Self: Sendable {
|
||||
/// Creates an asynchronous sequence that buffers elements using a buffer created from a supplied closure.
|
||||
///
|
||||
/// Use the `buffer(_:)` method to account for `AsyncSequence` types that may produce elements faster
|
||||
/// than they are iterated. The `createBuffer` closure returns a backing buffer for storing elements and dealing with
|
||||
/// behavioral characteristics of the `buffer(_:)` algorithm.
|
||||
///
|
||||
/// - Parameter createBuffer: A closure that constructs a new `AsyncBuffer` actor to store buffered values.
|
||||
/// - Returns: An asynchronous sequence that buffers elements using the specified `AsyncBuffer`.
|
||||
public func buffer<Buffer: AsyncBuffer>(_ createBuffer: @Sendable @escaping () -> Buffer) -> AsyncBufferSequence<Self, Buffer> where Buffer.Input == Element {
|
||||
AsyncBufferSequence(self, createBuffer: createBuffer)
|
||||
}
|
||||
|
||||
/// Creates an asynchronous sequence that buffers elements using a specific policy to limit the number of
|
||||
/// elements that are buffered.
|
||||
///
|
||||
/// - Parameter policy: A limiting policy behavior on the buffering behavior of the `AsyncBufferSequence`
|
||||
/// - Returns: An asynchronous sequence that buffers elements up to a given limit.
|
||||
public func buffer(policy limit: AsyncLimitBuffer<Element>.Policy) -> AsyncBufferSequence<Self, AsyncLimitBuffer<Element>> {
|
||||
buffer {
|
||||
AsyncLimitBuffer(policy: limit)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that buffers elements utilizing an `AsyncBuffer`.
|
||||
public struct AsyncBufferSequence<Base: AsyncSequence & Sendable, Buffer: AsyncBuffer> where Base.Element == Buffer.Input {
|
||||
let base: Base
|
||||
let createBuffer: @Sendable () -> Buffer
|
||||
|
||||
init(_ base: Base, createBuffer: @Sendable @escaping () -> Buffer) {
|
||||
self.base = base
|
||||
self.createBuffer = createBuffer
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncBufferSequence: Sendable where Base: Sendable { }
|
||||
|
||||
extension AsyncBufferSequence: AsyncSequence {
|
||||
public typealias Element = Buffer.Output
|
||||
|
||||
/// The iterator for a `AsyncBufferSequence` instance.
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
struct Active {
|
||||
var task: Task<Void, Never>?
|
||||
let buffer: Buffer
|
||||
let state: AsyncBufferState<Buffer.Input, Buffer.Output>
|
||||
|
||||
init(_ base: Base, buffer: Buffer, state: AsyncBufferState<Buffer.Input, Buffer.Output>) {
|
||||
self.buffer = buffer
|
||||
self.state = state
|
||||
task = Task {
|
||||
var iter = base.makeAsyncIterator()
|
||||
do {
|
||||
while let item = try await iter.next() {
|
||||
await state.enqueue(item, buffer: buffer)
|
||||
}
|
||||
await state.finish(buffer: buffer)
|
||||
} catch {
|
||||
await state.fail(error, buffer: buffer)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func next() async rethrows -> Element? {
|
||||
let result: Result<Element?, Error> = await withTaskCancellationHandler {
|
||||
do {
|
||||
let value = try await state.next(buffer: buffer)
|
||||
return .success(value)
|
||||
} catch {
|
||||
task?.cancel()
|
||||
return .failure(error)
|
||||
}
|
||||
} onCancel: {
|
||||
task?.cancel()
|
||||
}
|
||||
return try result._rethrowGet()
|
||||
}
|
||||
}
|
||||
|
||||
enum State {
|
||||
case idle(Base, @Sendable () -> Buffer)
|
||||
case active(Active)
|
||||
}
|
||||
|
||||
var state: State
|
||||
|
||||
init(_ base: Base, createBuffer: @Sendable @escaping () -> Buffer) {
|
||||
state = .idle(base, createBuffer)
|
||||
}
|
||||
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
switch state {
|
||||
case .idle(let base, let createBuffer):
|
||||
let bufferState = AsyncBufferState<Base.Element, Buffer.Output>()
|
||||
let buffer = Active(base, buffer: createBuffer(), state: bufferState)
|
||||
state = .active(buffer)
|
||||
return try await buffer.next()
|
||||
case .active(let buffer):
|
||||
return try await buffer.next()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(base, createBuffer: createBuffer)
|
||||
}
|
||||
}
|
||||
@@ -1,275 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@preconcurrency @_implementationOnly import OrderedCollections
|
||||
|
||||
/// A channel for sending elements from one task to another with back pressure.
|
||||
///
|
||||
/// The `AsyncChannel` class is intended to be used as a communication type between tasks,
|
||||
/// particularly when one task produces values and another task consumes those values. The back
|
||||
/// pressure applied by `send(_:)` via the suspension/resume ensures that
|
||||
/// the production of values does not exceed the consumption of values from iteration. This method
|
||||
/// suspends after enqueuing the event and is resumed when the next call to `next()`
|
||||
/// on the `Iterator` is made, or when `finish()` is called from another Task.
|
||||
/// As `finish()` induces a terminal state, there is no need for a back pressure management.
|
||||
/// This function does not suspend and will finish all the pending iterations.
|
||||
public final class AsyncChannel<Element: Sendable>: AsyncSequence, Sendable {
|
||||
/// The iterator for a `AsyncChannel` instance.
|
||||
public struct Iterator: AsyncIteratorProtocol, Sendable {
|
||||
let channel: AsyncChannel<Element>
|
||||
var active: Bool = true
|
||||
|
||||
init(_ channel: AsyncChannel<Element>) {
|
||||
self.channel = channel
|
||||
}
|
||||
|
||||
/// Await the next sent element or finish.
|
||||
public mutating func next() async -> Element? {
|
||||
guard active else {
|
||||
return nil
|
||||
}
|
||||
|
||||
let generation = channel.establish()
|
||||
let nextTokenStatus = ManagedCriticalState<ChannelTokenStatus>(.new)
|
||||
|
||||
let value = await withTaskCancellationHandler {
|
||||
await channel.next(nextTokenStatus, generation)
|
||||
} onCancel: { [channel] in
|
||||
channel.cancelNext(nextTokenStatus, generation)
|
||||
}
|
||||
|
||||
if let value {
|
||||
return value
|
||||
} else {
|
||||
active = false
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
typealias Pending = ChannelToken<UnsafeContinuation<UnsafeContinuation<Element?, Never>?, Never>>
|
||||
typealias Awaiting = ChannelToken<UnsafeContinuation<Element?, Never>>
|
||||
|
||||
struct ChannelToken<Continuation: Sendable>: Hashable, Sendable {
|
||||
var generation: Int
|
||||
var continuation: Continuation?
|
||||
|
||||
init(generation: Int, continuation: Continuation) {
|
||||
self.generation = generation
|
||||
self.continuation = continuation
|
||||
}
|
||||
|
||||
init(placeholder generation: Int) {
|
||||
self.generation = generation
|
||||
self.continuation = nil
|
||||
}
|
||||
|
||||
func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(generation)
|
||||
}
|
||||
|
||||
static func == (_ lhs: ChannelToken, _ rhs: ChannelToken) -> Bool {
|
||||
return lhs.generation == rhs.generation
|
||||
}
|
||||
}
|
||||
|
||||
enum ChannelTokenStatus: Equatable {
|
||||
case new
|
||||
case cancelled
|
||||
}
|
||||
|
||||
enum Emission : Sendable {
|
||||
case idle
|
||||
case pending(OrderedSet<Pending>)
|
||||
case awaiting(OrderedSet<Awaiting>)
|
||||
case finished
|
||||
}
|
||||
|
||||
struct State : Sendable {
|
||||
var emission: Emission = .idle
|
||||
var generation = 0
|
||||
}
|
||||
|
||||
let state = ManagedCriticalState(State())
|
||||
|
||||
/// Create a new `AsyncChannel` given an element type.
|
||||
public init(element elementType: Element.Type = Element.self) { }
|
||||
|
||||
func establish() -> Int {
|
||||
state.withCriticalRegion { state in
|
||||
defer { state.generation &+= 1 }
|
||||
return state.generation
|
||||
}
|
||||
}
|
||||
|
||||
func cancelNext(_ nextTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) {
|
||||
state.withCriticalRegion { state in
|
||||
let continuation: UnsafeContinuation<Element?, Never>?
|
||||
|
||||
switch state.emission {
|
||||
case .awaiting(var nexts):
|
||||
continuation = nexts.remove(Awaiting(placeholder: generation))?.continuation
|
||||
if nexts.isEmpty {
|
||||
state.emission = .idle
|
||||
} else {
|
||||
state.emission = .awaiting(nexts)
|
||||
}
|
||||
default:
|
||||
continuation = nil
|
||||
}
|
||||
|
||||
nextTokenStatus.withCriticalRegion { status in
|
||||
if status == .new {
|
||||
status = .cancelled
|
||||
}
|
||||
}
|
||||
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
|
||||
func next(_ nextTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) async -> Element? {
|
||||
return await withUnsafeContinuation { (continuation: UnsafeContinuation<Element?, Never>) in
|
||||
var cancelled = false
|
||||
var terminal = false
|
||||
state.withCriticalRegion { state in
|
||||
|
||||
if nextTokenStatus.withCriticalRegion({ $0 }) == .cancelled {
|
||||
cancelled = true
|
||||
}
|
||||
|
||||
switch state.emission {
|
||||
case .idle:
|
||||
state.emission = .awaiting([Awaiting(generation: generation, continuation: continuation)])
|
||||
case .pending(var sends):
|
||||
let send = sends.removeFirst()
|
||||
if sends.count == 0 {
|
||||
state.emission = .idle
|
||||
} else {
|
||||
state.emission = .pending(sends)
|
||||
}
|
||||
send.continuation?.resume(returning: continuation)
|
||||
case .awaiting(var nexts):
|
||||
nexts.updateOrAppend(Awaiting(generation: generation, continuation: continuation))
|
||||
state.emission = .awaiting(nexts)
|
||||
case .finished:
|
||||
terminal = true
|
||||
}
|
||||
}
|
||||
|
||||
if cancelled || terminal {
|
||||
continuation.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func cancelSend(_ sendTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) {
|
||||
state.withCriticalRegion { state in
|
||||
let continuation: UnsafeContinuation<UnsafeContinuation<Element?, Never>?, Never>?
|
||||
|
||||
switch state.emission {
|
||||
case .pending(var sends):
|
||||
let send = sends.remove(Pending(placeholder: generation))
|
||||
if sends.isEmpty {
|
||||
state.emission = .idle
|
||||
} else {
|
||||
state.emission = .pending(sends)
|
||||
}
|
||||
continuation = send?.continuation
|
||||
default:
|
||||
continuation = nil
|
||||
}
|
||||
|
||||
sendTokenStatus.withCriticalRegion { status in
|
||||
if status == .new {
|
||||
status = .cancelled
|
||||
}
|
||||
}
|
||||
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
|
||||
func send(_ sendTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int, _ element: Element) async {
|
||||
let continuation: UnsafeContinuation<Element?, Never>? = await withUnsafeContinuation { continuation in
|
||||
state.withCriticalRegion { state in
|
||||
|
||||
if sendTokenStatus.withCriticalRegion({ $0 }) == .cancelled {
|
||||
continuation.resume(returning: nil)
|
||||
return
|
||||
}
|
||||
|
||||
switch state.emission {
|
||||
case .idle:
|
||||
state.emission = .pending([Pending(generation: generation, continuation: continuation)])
|
||||
case .pending(var sends):
|
||||
sends.updateOrAppend(Pending(generation: generation, continuation: continuation))
|
||||
state.emission = .pending(sends)
|
||||
case .awaiting(var nexts):
|
||||
let next = nexts.removeFirst().continuation
|
||||
if nexts.count == 0 {
|
||||
state.emission = .idle
|
||||
} else {
|
||||
state.emission = .awaiting(nexts)
|
||||
}
|
||||
continuation.resume(returning: next)
|
||||
case .finished:
|
||||
continuation.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
}
|
||||
continuation?.resume(returning: element)
|
||||
}
|
||||
|
||||
/// Send an element to an awaiting iteration. This function will resume when the next call to `next()` is made
|
||||
/// or when a call to `finish()` is made from another Task.
|
||||
/// If the channel is already finished then this returns immediately
|
||||
/// If the task is cancelled, this function will resume. Other sending operations from other tasks will remain active.
|
||||
public func send(_ element: Element) async {
|
||||
let generation = establish()
|
||||
let sendTokenStatus = ManagedCriticalState<ChannelTokenStatus>(.new)
|
||||
|
||||
await withTaskCancellationHandler {
|
||||
await send(sendTokenStatus, generation, element)
|
||||
} onCancel: { [weak self] in
|
||||
self?.cancelSend(sendTokenStatus, generation)
|
||||
}
|
||||
}
|
||||
|
||||
/// Send a finish to all awaiting iterations.
|
||||
/// All subsequent calls to `next(_:)` will resume immediately.
|
||||
public func finish() {
|
||||
state.withCriticalRegion { state in
|
||||
|
||||
defer { state.emission = .finished }
|
||||
|
||||
switch state.emission {
|
||||
case .pending(let sends):
|
||||
for send in sends {
|
||||
send.continuation?.resume(returning: nil)
|
||||
}
|
||||
case .awaiting(let nexts):
|
||||
for next in nexts {
|
||||
next.continuation?.resume(returning: nil)
|
||||
}
|
||||
default:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
/// Create an `Iterator` for iteration of an `AsyncChannel`
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
return Iterator(self)
|
||||
}
|
||||
}
|
||||
@@ -70,7 +70,7 @@ public struct AsyncChunksOfCountOrSignalSequence<Base: AsyncSequence, Collected:
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
typealias EitherMappedBase = AsyncMapSequence<Base, Either>
|
||||
typealias EitherMappedSignal = AsyncMapSequence<Signal, Either>
|
||||
typealias ChainedBase = AsyncChain2Sequence<EitherMappedBase, AsyncLazySequence<[Either]>>
|
||||
typealias ChainedBase = AsyncChain2Sequence<EitherMappedBase, AsyncSyncSequence<[Either]>>
|
||||
typealias Merged = AsyncMerge2Sequence<ChainedBase, EitherMappedSignal>
|
||||
|
||||
let count: Int?
|
||||
|
||||
+4
-4
@@ -14,8 +14,8 @@ extension Sequence {
|
||||
/// but on which operations, such as `map` and `filter`, are
|
||||
/// implemented asynchronously.
|
||||
@inlinable
|
||||
public var async: AsyncLazySequence<Self> {
|
||||
AsyncLazySequence(self)
|
||||
public var async: AsyncSyncSequence<Self> {
|
||||
AsyncSyncSequence(self)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -28,7 +28,7 @@ extension Sequence {
|
||||
/// This functions similarly to `LazySequence` by accessing elements sequentially
|
||||
/// in the iterator's `next()` method.
|
||||
@frozen
|
||||
public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
|
||||
public struct AsyncSyncSequence<Base: Sequence>: AsyncSequence {
|
||||
public typealias Element = Base.Element
|
||||
|
||||
@frozen
|
||||
@@ -66,4 +66,4 @@ public struct AsyncLazySequence<Base: Sequence>: AsyncSequence {
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncLazySequence: Sendable where Base: Sendable { }
|
||||
extension AsyncSyncSequence: Sendable where Base: Sendable { }
|
||||
@@ -1,320 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@preconcurrency @_implementationOnly import OrderedCollections
|
||||
|
||||
/// An error-throwing channel for sending elements from on task to another with back pressure.
|
||||
///
|
||||
/// The `AsyncThrowingChannel` class is intended to be used as a communication types between tasks,
|
||||
/// particularly when one task produces values and another task consumes those values. The back
|
||||
/// pressure applied by `send(_:)` via suspension/resume ensures that the production of values does
|
||||
/// not exceed the consumption of values from iteration. This method suspends after enqueuing the event
|
||||
/// and is resumed when the next call to `next()` on the `Iterator` is made, or when `finish()`/`fail(_:)` is called
|
||||
/// from another Task. As `finish()` and `fail(_:)` induce a terminal state, there is no need for a back pressure management.
|
||||
/// Those functions do not suspend and will finish all the pending iterations.
|
||||
public final class AsyncThrowingChannel<Element: Sendable, Failure: Error>: AsyncSequence, Sendable {
|
||||
/// The iterator for an `AsyncThrowingChannel` instance.
|
||||
public struct Iterator: AsyncIteratorProtocol, Sendable {
|
||||
let channel: AsyncThrowingChannel<Element, Failure>
|
||||
var active: Bool = true
|
||||
|
||||
init(_ channel: AsyncThrowingChannel<Element, Failure>) {
|
||||
self.channel = channel
|
||||
}
|
||||
|
||||
public mutating func next() async throws -> Element? {
|
||||
guard active else {
|
||||
return nil
|
||||
}
|
||||
|
||||
let generation = channel.establish()
|
||||
let nextTokenStatus = ManagedCriticalState<ChannelTokenStatus>(.new)
|
||||
|
||||
do {
|
||||
let value = try await withTaskCancellationHandler {
|
||||
try await channel.next(nextTokenStatus, generation)
|
||||
} onCancel: { [channel] in
|
||||
channel.cancelNext(nextTokenStatus, generation)
|
||||
}
|
||||
|
||||
if let value = value {
|
||||
return value
|
||||
} else {
|
||||
active = false
|
||||
return nil
|
||||
}
|
||||
} catch {
|
||||
active = false
|
||||
throw error
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
typealias Pending = ChannelToken<UnsafeContinuation<UnsafeContinuation<Element?, Error>?, Never>>
|
||||
typealias Awaiting = ChannelToken<UnsafeContinuation<Element?, Error>>
|
||||
|
||||
struct ChannelToken<Continuation: Sendable>: Hashable, Sendable {
|
||||
var generation: Int
|
||||
var continuation: Continuation?
|
||||
|
||||
init(generation: Int, continuation: Continuation) {
|
||||
self.generation = generation
|
||||
self.continuation = continuation
|
||||
}
|
||||
|
||||
init(placeholder generation: Int) {
|
||||
self.generation = generation
|
||||
self.continuation = nil
|
||||
}
|
||||
|
||||
func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(generation)
|
||||
}
|
||||
|
||||
static func == (_ lhs: ChannelToken, _ rhs: ChannelToken) -> Bool {
|
||||
return lhs.generation == rhs.generation
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
enum ChannelTokenStatus: Equatable {
|
||||
case new
|
||||
case cancelled
|
||||
}
|
||||
|
||||
enum Termination {
|
||||
case finished
|
||||
case failed(Error)
|
||||
}
|
||||
|
||||
enum Emission: Sendable {
|
||||
case idle
|
||||
case pending(OrderedSet<Pending>)
|
||||
case awaiting(OrderedSet<Awaiting>)
|
||||
case terminated(Termination)
|
||||
}
|
||||
|
||||
struct State : Sendable {
|
||||
var emission: Emission = .idle
|
||||
var generation = 0
|
||||
}
|
||||
|
||||
let state = ManagedCriticalState(State())
|
||||
|
||||
public init(_ elementType: Element.Type = Element.self) { }
|
||||
|
||||
func establish() -> Int {
|
||||
state.withCriticalRegion { state in
|
||||
defer { state.generation &+= 1 }
|
||||
return state.generation
|
||||
}
|
||||
}
|
||||
|
||||
func cancelNext(_ nextTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) {
|
||||
state.withCriticalRegion { state in
|
||||
let continuation: UnsafeContinuation<Element?, Error>?
|
||||
|
||||
switch state.emission {
|
||||
case .awaiting(var nexts):
|
||||
continuation = nexts.remove(Awaiting(placeholder: generation))?.continuation
|
||||
if nexts.isEmpty {
|
||||
state.emission = .idle
|
||||
} else {
|
||||
state.emission = .awaiting(nexts)
|
||||
}
|
||||
default:
|
||||
continuation = nil
|
||||
}
|
||||
|
||||
nextTokenStatus.withCriticalRegion { status in
|
||||
if status == .new {
|
||||
status = .cancelled
|
||||
}
|
||||
}
|
||||
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
|
||||
func next(_ nextTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) async throws -> Element? {
|
||||
return try await withUnsafeThrowingContinuation { (continuation: UnsafeContinuation<Element?, Error>) in
|
||||
var cancelled = false
|
||||
var potentialTermination: Termination?
|
||||
|
||||
state.withCriticalRegion { state in
|
||||
|
||||
if nextTokenStatus.withCriticalRegion({ $0 }) == .cancelled {
|
||||
cancelled = true
|
||||
return
|
||||
}
|
||||
|
||||
switch state.emission {
|
||||
case .idle:
|
||||
state.emission = .awaiting([Awaiting(generation: generation, continuation: continuation)])
|
||||
case .pending(var sends):
|
||||
let send = sends.removeFirst()
|
||||
if sends.count == 0 {
|
||||
state.emission = .idle
|
||||
} else {
|
||||
state.emission = .pending(sends)
|
||||
}
|
||||
send.continuation?.resume(returning: continuation)
|
||||
case .awaiting(var nexts):
|
||||
nexts.updateOrAppend(Awaiting(generation: generation, continuation: continuation))
|
||||
state.emission = .awaiting(nexts)
|
||||
case .terminated(let termination):
|
||||
potentialTermination = termination
|
||||
state.emission = .terminated(.finished)
|
||||
}
|
||||
}
|
||||
|
||||
if cancelled {
|
||||
continuation.resume(returning: nil)
|
||||
return
|
||||
}
|
||||
|
||||
switch potentialTermination {
|
||||
case .none:
|
||||
return
|
||||
case .failed(let error):
|
||||
continuation.resume(throwing: error)
|
||||
return
|
||||
case .finished:
|
||||
continuation.resume(returning: nil)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func cancelSend(_ sendTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int) {
|
||||
state.withCriticalRegion { state in
|
||||
let continuation: UnsafeContinuation<UnsafeContinuation<Element?, Error>?, Never>?
|
||||
|
||||
switch state.emission {
|
||||
case .pending(var sends):
|
||||
let send = sends.remove(Pending(placeholder: generation))
|
||||
if sends.isEmpty {
|
||||
state.emission = .idle
|
||||
} else {
|
||||
state.emission = .pending(sends)
|
||||
}
|
||||
continuation = send?.continuation
|
||||
default:
|
||||
continuation = nil
|
||||
}
|
||||
|
||||
sendTokenStatus.withCriticalRegion { status in
|
||||
if status == .new {
|
||||
status = .cancelled
|
||||
}
|
||||
}
|
||||
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
|
||||
func send(_ sendTokenStatus: ManagedCriticalState<ChannelTokenStatus>, _ generation: Int, _ element: Element) async {
|
||||
let continuation: UnsafeContinuation<Element?, Error>? = await withUnsafeContinuation { continuation in
|
||||
state.withCriticalRegion { state in
|
||||
|
||||
if sendTokenStatus.withCriticalRegion({ $0 }) == .cancelled {
|
||||
continuation.resume(returning: nil)
|
||||
return
|
||||
}
|
||||
|
||||
switch state.emission {
|
||||
case .idle:
|
||||
state.emission = .pending([Pending(generation: generation, continuation: continuation)])
|
||||
case .pending(var sends):
|
||||
sends.updateOrAppend(Pending(generation: generation, continuation: continuation))
|
||||
state.emission = .pending(sends)
|
||||
case .awaiting(var nexts):
|
||||
let next = nexts.removeFirst().continuation
|
||||
if nexts.count == 0 {
|
||||
state.emission = .idle
|
||||
} else {
|
||||
state.emission = .awaiting(nexts)
|
||||
}
|
||||
continuation.resume(returning: next)
|
||||
case .terminated:
|
||||
continuation.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
}
|
||||
continuation?.resume(returning: element)
|
||||
}
|
||||
|
||||
func terminateAll(error: Failure? = nil) {
|
||||
state.withCriticalRegion { state in
|
||||
|
||||
let nextState: Emission
|
||||
if let error = error {
|
||||
nextState = .terminated(.failed(error))
|
||||
} else {
|
||||
nextState = .terminated(.finished)
|
||||
}
|
||||
|
||||
switch state.emission {
|
||||
case .idle:
|
||||
state.emission = nextState
|
||||
case .pending(let sends):
|
||||
state.emission = nextState
|
||||
for send in sends {
|
||||
send.continuation?.resume(returning: nil)
|
||||
}
|
||||
case .awaiting(let nexts):
|
||||
state.emission = nextState
|
||||
if let error = error {
|
||||
for next in nexts {
|
||||
next.continuation?.resume(throwing: error)
|
||||
}
|
||||
} else {
|
||||
for next in nexts {
|
||||
next.continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
case .terminated:
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Send an element to an awaiting iteration. This function will resume when the next call to `next()` is made
|
||||
/// or when a call to `finish()`/`fail(_:)` is made from another Task.
|
||||
/// If the channel is already finished then this returns immediately
|
||||
/// If the task is cancelled, this function will resume. Other sending operations from other tasks will remain active.
|
||||
public func send(_ element: Element) async {
|
||||
let generation = establish()
|
||||
let sendTokenStatus = ManagedCriticalState<ChannelTokenStatus>(.new)
|
||||
|
||||
await withTaskCancellationHandler {
|
||||
await send(sendTokenStatus, generation, element)
|
||||
} onCancel: { [weak self] in
|
||||
self?.cancelSend(sendTokenStatus, generation)
|
||||
}
|
||||
}
|
||||
|
||||
/// Send an error to all awaiting iterations.
|
||||
/// All subsequent calls to `next(_:)` will resume immediately.
|
||||
public func fail(_ error: Error) where Failure == Error {
|
||||
terminateAll(error: error)
|
||||
}
|
||||
|
||||
/// Send a finish to all awaiting iterations.
|
||||
/// All subsequent calls to `next(_:)` will resume immediately.
|
||||
public func finish() {
|
||||
terminateAll()
|
||||
}
|
||||
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
return Iterator(self)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension AsyncSequence where Self: Sendable {
|
||||
/// Creates an asynchronous sequence that buffers elements.
|
||||
///
|
||||
/// The buffering behaviour is dictated by the policy:
|
||||
/// - bounded: will buffer elements until the limit is reached. Then it will suspend the upstream async sequence.
|
||||
/// - unbounded: will buffer elements without limit.
|
||||
/// - bufferingNewest: will buffer elements until the limit is reached. Then it will discard the oldest elements.
|
||||
/// - bufferingOldest: will buffer elements until the limit is reached. Then it will discard the newest elements.
|
||||
///
|
||||
/// - Parameter policy: A policy that drives the behaviour of the ``AsyncBufferSequence``
|
||||
/// - Returns: An asynchronous sequence that buffers elements up to a given limit.
|
||||
public func buffer(
|
||||
policy: AsyncBufferSequencePolicy
|
||||
) -> AsyncBufferSequence<Self> {
|
||||
AsyncBufferSequence<Self>(base: self, policy: policy)
|
||||
}
|
||||
}
|
||||
|
||||
/// A policy dictating the buffering behaviour of an ``AsyncBufferSequence``
|
||||
public struct AsyncBufferSequencePolicy: Sendable {
|
||||
enum _Policy {
|
||||
case bounded(Int)
|
||||
case unbounded
|
||||
case bufferingNewest(Int)
|
||||
case bufferingOldest(Int)
|
||||
}
|
||||
|
||||
let policy: _Policy
|
||||
|
||||
/// A policy for buffering elements until the limit is reached.
|
||||
/// Then consumption of the upstream `AsyncSequence` will be paused until elements are consumed from the buffer.
|
||||
/// If the limit is zero then no buffering policy is applied.
|
||||
public static func bounded(_ limit: Int) -> Self {
|
||||
precondition(limit >= 0, "The limit should be positive or equal to 0.")
|
||||
return Self(policy: .bounded(limit))
|
||||
}
|
||||
|
||||
/// A policy for buffering elements without limit.
|
||||
public static var unbounded: Self {
|
||||
return Self(policy: .unbounded)
|
||||
}
|
||||
|
||||
/// A policy for buffering elements until the limit is reached.
|
||||
/// After the limit is reached and a new element is produced by the upstream, the oldest buffered element will be discarded.
|
||||
/// If the limit is zero then no buffering policy is applied.
|
||||
public static func bufferingLatest(_ limit: Int) -> Self {
|
||||
precondition(limit >= 0, "The limit should be positive or equal to 0.")
|
||||
return Self(policy: .bufferingNewest(limit))
|
||||
}
|
||||
|
||||
/// A policy for buffering elements until the limit is reached.
|
||||
/// After the limit is reached and a new element is produced by the upstream, the latest buffered element will be discarded.
|
||||
/// If the limit is zero then no buffering policy is applied.
|
||||
public static func bufferingOldest(_ limit: Int) -> Self {
|
||||
precondition(limit >= 0, "The limit should be positive or equal to 0.")
|
||||
return Self(policy: .bufferingOldest(limit))
|
||||
}
|
||||
}
|
||||
|
||||
/// An `AsyncSequence` that buffers elements in regard to a policy.
|
||||
public struct AsyncBufferSequence<Base: AsyncSequence & Sendable>: AsyncSequence {
|
||||
enum StorageType<Base: AsyncSequence> {
|
||||
case transparent(Base.AsyncIterator)
|
||||
case bounded(storage: BoundedBufferStorage<Base>)
|
||||
case unbounded(storage: UnboundedBufferStorage<Base>)
|
||||
}
|
||||
|
||||
public typealias Element = Base.Element
|
||||
public typealias AsyncIterator = Iterator
|
||||
|
||||
let base: Base
|
||||
let policy: AsyncBufferSequencePolicy
|
||||
|
||||
public init(
|
||||
base: Base,
|
||||
policy: AsyncBufferSequencePolicy
|
||||
) {
|
||||
self.base = base
|
||||
self.policy = policy
|
||||
}
|
||||
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
let storageType: StorageType<Base>
|
||||
switch self.policy.policy {
|
||||
case .bounded(...0), .bufferingNewest(...0), .bufferingOldest(...0):
|
||||
storageType = .transparent(self.base.makeAsyncIterator())
|
||||
case .bounded(let limit):
|
||||
storageType = .bounded(storage: BoundedBufferStorage(base: self.base, limit: limit))
|
||||
case .unbounded:
|
||||
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .unlimited))
|
||||
case .bufferingNewest(let limit):
|
||||
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .bufferingNewest(limit)))
|
||||
case .bufferingOldest(let limit):
|
||||
storageType = .unbounded(storage: UnboundedBufferStorage(base: self.base, policy: .bufferingOldest(limit)))
|
||||
}
|
||||
return Iterator(storageType: storageType)
|
||||
}
|
||||
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
var storageType: StorageType<Base>
|
||||
|
||||
public mutating func next() async rethrows -> Element? {
|
||||
switch self.storageType {
|
||||
case .transparent(var iterator):
|
||||
let element = try await iterator.next()
|
||||
self.storageType = .transparent(iterator)
|
||||
return element
|
||||
case .bounded(let storage):
|
||||
return try await storage.next()?._rethrowGet()
|
||||
case .unbounded(let storage):
|
||||
return try await storage.next()?._rethrowGet()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension AsyncBufferSequence: Sendable where Base: Sendable { }
|
||||
|
||||
@available(*, unavailable)
|
||||
extension AsyncBufferSequence.Iterator: Sendable { }
|
||||
@@ -0,0 +1,310 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@_implementationOnly import DequeModule
|
||||
|
||||
struct BoundedBufferStateMachine<Base: AsyncSequence> {
|
||||
typealias Element = Base.Element
|
||||
typealias SuspendedProducer = UnsafeContinuation<Void, Never>
|
||||
typealias SuspendedConsumer = UnsafeContinuation<Result<Base.Element, Error>?, Never>
|
||||
|
||||
private enum State {
|
||||
case initial(base: Base)
|
||||
case buffering(
|
||||
task: Task<Void, Never>,
|
||||
buffer: Deque<Result<Element, Error>>,
|
||||
suspendedProducer: SuspendedProducer?,
|
||||
suspendedConsumer: SuspendedConsumer?
|
||||
)
|
||||
case modifying
|
||||
case finished(buffer: Deque<Result<Element, Error>>)
|
||||
}
|
||||
|
||||
private var state: State
|
||||
private let limit: Int
|
||||
|
||||
init(base: Base, limit: Int) {
|
||||
self.state = .initial(base: base)
|
||||
self.limit = limit
|
||||
}
|
||||
|
||||
var task: Task<Void, Never>? {
|
||||
switch self.state {
|
||||
case .buffering(let task, _, _, _):
|
||||
return task
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
mutating func taskStarted(task: Task<Void, Never>) {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
self.state = .buffering(task: task, buffer: [], suspendedProducer: nil, suspendedConsumer: nil)
|
||||
|
||||
case .buffering:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
preconditionFailure("Invalid state.")
|
||||
}
|
||||
}
|
||||
|
||||
mutating func shouldSuspendProducer() -> Bool {
|
||||
switch state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(_, let buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if there are free slots, we should directly request the next element
|
||||
return buffer.count >= self.limit
|
||||
|
||||
case .buffering(_, _, .none, .some):
|
||||
// we have an awaiting consumer, we should not suspended the producer, we should
|
||||
// directly request the next element
|
||||
return false
|
||||
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There is already a suspended producer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
enum ProducerSuspendedAction {
|
||||
case none
|
||||
case resumeProducer
|
||||
}
|
||||
|
||||
mutating func producerSuspended(continuation: SuspendedProducer) -> ProducerSuspendedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(let task, let buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if the buffer is available we resume the producer so it can we can request the next element
|
||||
// otherwise we confirm the suspension
|
||||
if buffer.count < limit {
|
||||
return .resumeProducer
|
||||
} else {
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: continuation, suspendedConsumer: nil)
|
||||
return .none
|
||||
}
|
||||
|
||||
case .buffering(_, let buffer, .none, .some):
|
||||
// we have an awaiting consumer, we can resume the producer so the next element can be requested
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty as we have an awaiting consumer already.")
|
||||
return .resumeProducer
|
||||
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There is already a suspended producer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return .resumeProducer
|
||||
}
|
||||
}
|
||||
|
||||
enum ElementProducedAction {
|
||||
case none
|
||||
case resumeConsumer(continuation: SuspendedConsumer, result: Result<Element, Error>)
|
||||
}
|
||||
|
||||
mutating func elementProduced(element: Element) -> ElementProducedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(let task, var buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// we have to stack the new element or suspend the producer if the buffer is full
|
||||
precondition(buffer.count < limit, "Invalid state. The buffer should be available for stacking a new element.")
|
||||
self.state = .modifying
|
||||
buffer.append(.success(element))
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .none
|
||||
|
||||
case .buffering(let task, let buffer, .none, .some(let suspendedConsumer)):
|
||||
// we have an awaiting consumer, we can resume it with the element and exit
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .resumeConsumer(continuation: suspendedConsumer, result: .success(element))
|
||||
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There should not be a suspended producer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
enum FinishAction {
|
||||
case none
|
||||
case resumeConsumer(
|
||||
continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>?
|
||||
)
|
||||
}
|
||||
|
||||
mutating func finish(error: Error?) -> FinishAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(_, var buffer, .none, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if we have an error we stack it in the buffer so it can be consumed later
|
||||
if let error {
|
||||
buffer.append(.failure(error))
|
||||
}
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .none
|
||||
|
||||
case .buffering(_, let buffer, .none, .some(let suspendedConsumer)):
|
||||
// we have an awaiting consumer, we can resume it
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeConsumer(continuation: suspendedConsumer)
|
||||
|
||||
case .buffering(_, _, .some, _):
|
||||
preconditionFailure("Invalid state. There should not be a suspended producer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
enum NextAction {
|
||||
case startTask(base: Base)
|
||||
case suspend
|
||||
case returnResult(producerContinuation: UnsafeContinuation<Void, Never>?, result: Result<Element, Error>?)
|
||||
}
|
||||
|
||||
mutating func next() -> NextAction {
|
||||
switch state {
|
||||
case .initial(let base):
|
||||
return .startTask(base: base)
|
||||
|
||||
case .buffering(_, let buffer, .none, .none) where buffer.isEmpty:
|
||||
// we are idle, we must suspend the consumer
|
||||
return .suspend
|
||||
|
||||
case .buffering(let task, var buffer, let suspendedProducer, .none):
|
||||
// we have values in the buffer, we unstack the oldest one and resume a potential suspended producer
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .returnResult(producerContinuation: suspendedProducer, result: result)
|
||||
|
||||
case .buffering(_, _, _, .some):
|
||||
preconditionFailure("Invalid states. There is already a suspended consumer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .returnResult(producerContinuation: nil, result: nil)
|
||||
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .returnResult(producerContinuation: nil, result: result)
|
||||
}
|
||||
}
|
||||
|
||||
enum NextSuspendedAction {
|
||||
case none
|
||||
case returnResult(producerContinuation: UnsafeContinuation<Void, Never>?, result: Result<Element, Error>?)
|
||||
}
|
||||
|
||||
mutating func nextSuspended(continuation: SuspendedConsumer) -> NextSuspendedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(let task, let buffer, .none, .none) where buffer.isEmpty:
|
||||
// we are idle, we confirm the suspension of the consumer
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: continuation)
|
||||
return .none
|
||||
|
||||
case .buffering(let task, var buffer, let suspendedProducer, .none):
|
||||
// we have values in the buffer, we unstack the oldest one and resume a potential suspended producer
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedProducer: nil, suspendedConsumer: nil)
|
||||
return .returnResult(producerContinuation: suspendedProducer, result: result)
|
||||
|
||||
case .buffering(_, _, _, .some):
|
||||
preconditionFailure("Invalid states. There is already a suspended consumer.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .returnResult(producerContinuation: nil, result: nil)
|
||||
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .returnResult(producerContinuation: nil, result: result)
|
||||
}
|
||||
}
|
||||
|
||||
enum InterruptedAction {
|
||||
case none
|
||||
case resumeProducerAndConsumer(
|
||||
task: Task<Void, Never>,
|
||||
producerContinuation: UnsafeContinuation<Void, Never>?,
|
||||
consumerContinuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>?
|
||||
)
|
||||
}
|
||||
|
||||
mutating func interrupted() -> InterruptedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
self.state = .finished(buffer: [])
|
||||
return .none
|
||||
|
||||
case .buffering(let task, _, let suspendedProducer, let suspendedConsumer):
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeProducerAndConsumer(
|
||||
task: task,
|
||||
producerContinuation: suspendedProducer,
|
||||
consumerContinuation: suspendedConsumer
|
||||
)
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
self.state = .finished(buffer: [])
|
||||
return .none
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,142 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Sendable {
|
||||
private let stateMachine: ManagedCriticalState<BoundedBufferStateMachine<Base>>
|
||||
|
||||
init(base: Base, limit: Int) {
|
||||
self.stateMachine = ManagedCriticalState(BoundedBufferStateMachine(base: base, limit: limit))
|
||||
}
|
||||
|
||||
func next() async -> Result<Base.Element, Error>? {
|
||||
return await withTaskCancellationHandler {
|
||||
let (shouldSuspend, result) = self.stateMachine.withCriticalRegion { stateMachine -> (Bool, Result<Base.Element, Error>?) in
|
||||
let action = stateMachine.next()
|
||||
switch action {
|
||||
case .startTask(let base):
|
||||
self.startTask(stateMachine: &stateMachine, base: base)
|
||||
return (true, nil)
|
||||
case .suspend:
|
||||
return (true, nil)
|
||||
case .returnResult(let producerContinuation, let result):
|
||||
producerContinuation?.resume()
|
||||
return (false, result)
|
||||
}
|
||||
}
|
||||
|
||||
if !shouldSuspend {
|
||||
return result
|
||||
}
|
||||
|
||||
return await withUnsafeContinuation { (continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.nextSuspended(continuation: continuation)
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .returnResult(let producerContinuation, let result):
|
||||
producerContinuation?.resume()
|
||||
continuation.resume(returning: result)
|
||||
}
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
self.interrupted()
|
||||
}
|
||||
}
|
||||
|
||||
private func startTask(
|
||||
stateMachine: inout BoundedBufferStateMachine<Base>,
|
||||
base: Base
|
||||
) {
|
||||
let task = Task {
|
||||
do {
|
||||
var iterator = base.makeAsyncIterator()
|
||||
|
||||
loop: while true {
|
||||
let shouldSuspend = self.stateMachine.withCriticalRegion { stateMachine -> Bool in
|
||||
return stateMachine.shouldSuspendProducer()
|
||||
}
|
||||
|
||||
if shouldSuspend {
|
||||
await withUnsafeContinuation { (continuation: UnsafeContinuation<Void, Never>) in
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.producerSuspended(continuation: continuation)
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducer:
|
||||
continuation.resume()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
guard let element = try await iterator.next() else {
|
||||
// the upstream is finished
|
||||
break loop
|
||||
}
|
||||
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.elementProduced(element: element)
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation, let result):
|
||||
continuation.resume(returning: result)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.finish(error: nil)
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.finish(error: error)
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: .failure(error))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stateMachine.taskStarted(task: task)
|
||||
}
|
||||
|
||||
func interrupted() {
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.interrupted()
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducerAndConsumer(let task, let producerContinuation, let consumerContinuation):
|
||||
task.cancel()
|
||||
producerContinuation?.resume()
|
||||
consumerContinuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
deinit {
|
||||
self.interrupted()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,250 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@_implementationOnly import DequeModule
|
||||
|
||||
struct UnboundedBufferStateMachine<Base: AsyncSequence> {
|
||||
typealias Element = Base.Element
|
||||
typealias SuspendedConsumer = UnsafeContinuation<Result<Element, Error>?, Never>
|
||||
|
||||
enum Policy {
|
||||
case unlimited
|
||||
case bufferingNewest(Int)
|
||||
case bufferingOldest(Int)
|
||||
}
|
||||
|
||||
private enum State {
|
||||
case initial(base: Base)
|
||||
case buffering(
|
||||
task: Task<Void, Never>,
|
||||
buffer: Deque<Result<Element, Error>>,
|
||||
suspendedConsumer: SuspendedConsumer?
|
||||
)
|
||||
case modifying
|
||||
case finished(buffer: Deque<Result<Element, Error>>)
|
||||
}
|
||||
|
||||
private var state: State
|
||||
private let policy: Policy
|
||||
|
||||
init(base: Base, policy: Policy) {
|
||||
self.state = .initial(base: base)
|
||||
self.policy = policy
|
||||
}
|
||||
|
||||
var task: Task<Void, Never>? {
|
||||
switch self.state {
|
||||
case .buffering(let task, _, _):
|
||||
return task
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
mutating func taskStarted(task: Task<Void, Never>) {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
self.state = .buffering(task: task, buffer: [], suspendedConsumer: nil)
|
||||
|
||||
case .buffering:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
preconditionFailure("Invalid state.")
|
||||
}
|
||||
}
|
||||
|
||||
enum ElementProducedAction {
|
||||
case none
|
||||
case resumeConsumer(
|
||||
continuation: SuspendedConsumer,
|
||||
result: Result<Element, Error>
|
||||
)
|
||||
}
|
||||
|
||||
mutating func elementProduced(element: Element) -> ElementProducedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(let task, var buffer, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// we have to apply the policy when stacking the new element
|
||||
self.state = .modifying
|
||||
switch self.policy {
|
||||
case .unlimited:
|
||||
buffer.append(.success(element))
|
||||
case .bufferingNewest(let limit):
|
||||
if buffer.count >= limit {
|
||||
_ = buffer.popFirst()
|
||||
}
|
||||
buffer.append(.success(element))
|
||||
case .bufferingOldest(let limit):
|
||||
if buffer.count < limit {
|
||||
buffer.append(.success(element))
|
||||
}
|
||||
}
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .none
|
||||
|
||||
case .buffering(let task, let buffer, .some(let suspendedConsumer)):
|
||||
// we have an awaiting consumer, we can resume it with the element
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .resumeConsumer(
|
||||
continuation: suspendedConsumer,
|
||||
result: .success(element)
|
||||
)
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
enum FinishAction {
|
||||
case none
|
||||
case resumeConsumer(continuation: SuspendedConsumer?)
|
||||
}
|
||||
|
||||
mutating func finish(error: Error?) -> FinishAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(_, var buffer, .none):
|
||||
// we are either idle or the buffer is already in use (no awaiting consumer)
|
||||
// if we have an error we stack it in the buffer so it can be consumed later
|
||||
if let error {
|
||||
buffer.append(.failure(error))
|
||||
}
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .none
|
||||
|
||||
case .buffering(_, let buffer, let suspendedConsumer):
|
||||
// we have an awaiting consumer, we can resume it with nil or the error
|
||||
precondition(buffer.isEmpty, "Invalid state. The buffer should be empty.")
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeConsumer(continuation: suspendedConsumer)
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
enum NextAction {
|
||||
case startTask(base: Base)
|
||||
case suspend
|
||||
case returnResult(Result<Element, Error>?)
|
||||
}
|
||||
|
||||
mutating func next() -> NextAction {
|
||||
switch self.state {
|
||||
case .initial(let base):
|
||||
return .startTask(base: base)
|
||||
|
||||
case .buffering(_, let buffer, let suspendedConsumer) where buffer.isEmpty:
|
||||
// we are idle, we have to suspend the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
return .suspend
|
||||
|
||||
case .buffering(let task, var buffer, let suspendedConsumer):
|
||||
// the buffer is already in use, we can unstack a value and directly resume the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .returnResult(result)
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .returnResult(nil)
|
||||
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .returnResult(result)
|
||||
}
|
||||
}
|
||||
|
||||
enum NextSuspendedAction {
|
||||
case none
|
||||
case resumeConsumer(Result<Element, Error>?)
|
||||
}
|
||||
|
||||
mutating func nextSuspended(continuation: SuspendedConsumer) -> NextSuspendedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Invalid state. The task should already by started.")
|
||||
|
||||
case .buffering(let task, let buffer, let suspendedConsumer) where buffer.isEmpty:
|
||||
// we are idle, we confirm the suspension of the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: continuation)
|
||||
return .none
|
||||
|
||||
case .buffering(let task, var buffer, let suspendedConsumer):
|
||||
// the buffer is already in use, we can unstack a value and directly resume the consumer
|
||||
precondition(suspendedConsumer == nil, "Invalid states. There is already a suspended consumer.")
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .buffering(task: task, buffer: buffer, suspendedConsumer: nil)
|
||||
return .resumeConsumer(result)
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished(let buffer) where buffer.isEmpty:
|
||||
return .resumeConsumer(nil)
|
||||
|
||||
case .finished(var buffer):
|
||||
self.state = .modifying
|
||||
let result = buffer.popFirst()!
|
||||
self.state = .finished(buffer: buffer)
|
||||
return .resumeConsumer(result)
|
||||
}
|
||||
}
|
||||
|
||||
enum InterruptedAction {
|
||||
case none
|
||||
case resumeConsumer(task: Task<Void, Never>, continuation: SuspendedConsumer?)
|
||||
}
|
||||
|
||||
mutating func interrupted() -> InterruptedAction {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
state = .finished(buffer: [])
|
||||
return .none
|
||||
|
||||
case .buffering(let task, _, let suspendedConsumer):
|
||||
self.state = .finished(buffer: [])
|
||||
return .resumeConsumer(task: task, continuation: suspendedConsumer)
|
||||
|
||||
case .modifying:
|
||||
preconditionFailure("Invalid state.")
|
||||
|
||||
case .finished:
|
||||
self.state = .finished(buffer: [])
|
||||
return .none
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Sendable {
|
||||
private let stateMachine: ManagedCriticalState<UnboundedBufferStateMachine<Base>>
|
||||
|
||||
init(base: Base, policy: UnboundedBufferStateMachine<Base>.Policy) {
|
||||
self.stateMachine = ManagedCriticalState(UnboundedBufferStateMachine<Base>(base: base, policy: policy))
|
||||
}
|
||||
|
||||
func next() async -> Result<Base.Element, Error>? {
|
||||
return await withTaskCancellationHandler {
|
||||
|
||||
let (shouldSuspend, result) = self.stateMachine.withCriticalRegion { stateMachine -> (Bool, Result<Base.Element, Error>?) in
|
||||
let action = stateMachine.next()
|
||||
switch action {
|
||||
case .startTask(let base):
|
||||
self.startTask(stateMachine: &stateMachine, base: base)
|
||||
return (true, nil)
|
||||
case .suspend:
|
||||
return (true, nil)
|
||||
case .returnResult(let result):
|
||||
return (false, result)
|
||||
}
|
||||
}
|
||||
|
||||
if !shouldSuspend {
|
||||
return result
|
||||
}
|
||||
|
||||
return await withUnsafeContinuation { (continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.nextSuspended(continuation: continuation)
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let result):
|
||||
continuation.resume(returning: result)
|
||||
}
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
self.interrupted()
|
||||
}
|
||||
}
|
||||
|
||||
private func startTask(
|
||||
stateMachine: inout UnboundedBufferStateMachine<Base>,
|
||||
base: Base
|
||||
) {
|
||||
let task = Task {
|
||||
do {
|
||||
for try await element in base {
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.elementProduced(element: element)
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation, let result):
|
||||
continuation.resume(returning: result)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.finish(error: nil)
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.finish(error: error)
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: .failure(error))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stateMachine.taskStarted(task: task)
|
||||
}
|
||||
|
||||
func interrupted() {
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.interrupted()
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let task, let continuation):
|
||||
task.cancel()
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
deinit {
|
||||
self.interrupted()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A channel for sending elements from one task to another with back pressure.
|
||||
///
|
||||
/// The `AsyncChannel` class is intended to be used as a communication type between tasks,
|
||||
/// particularly when one task produces values and another task consumes those values. The back
|
||||
/// pressure applied by `send(_:)` via the suspension/resume ensures that
|
||||
/// the production of values does not exceed the consumption of values from iteration. This method
|
||||
/// suspends after enqueuing the event and is resumed when the next call to `next()`
|
||||
/// on the `Iterator` is made, or when `finish()` is called from another Task.
|
||||
/// As `finish()` induces a terminal state, there is no more need for a back pressure management.
|
||||
/// This function does not suspend and will finish all the pending iterations.
|
||||
public final class AsyncChannel<Element>: AsyncSequence, @unchecked Sendable {
|
||||
public typealias Element = Element
|
||||
public typealias AsyncIterator = Iterator
|
||||
|
||||
let storage: ChannelStorage<Element, Never>
|
||||
|
||||
public init() {
|
||||
self.storage = ChannelStorage()
|
||||
}
|
||||
|
||||
/// Sends an element to an awaiting iteration. This function will resume when the next call to `next()` is made
|
||||
/// or when a call to `finish()` is made from another task.
|
||||
/// If the channel is already finished then this returns immediately.
|
||||
/// If the task is cancelled, this function will resume without sending the element.
|
||||
/// Other sending operations from other tasks will remain active.
|
||||
public func send(_ element: Element) async {
|
||||
await self.storage.send(element: element)
|
||||
}
|
||||
|
||||
/// Immediately resumes all the suspended operations.
|
||||
/// All subsequent calls to `next(_:)` will resume immediately.
|
||||
public func finish() {
|
||||
self.storage.finish()
|
||||
}
|
||||
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(storage: self.storage)
|
||||
}
|
||||
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
let storage: ChannelStorage<Element, Never>
|
||||
|
||||
public mutating func next() async -> Element? {
|
||||
// Although the storage can throw, its usage in the context of an `AsyncChannel` guarantees it cannot.
|
||||
// There is no public way of sending a failure to it.
|
||||
try! await self.storage.next()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// An error-throwing channel for sending elements from on task to another with back pressure.
|
||||
///
|
||||
/// The `AsyncThrowingChannel` class is intended to be used as a communication types between tasks,
|
||||
/// particularly when one task produces values and another task consumes those values. The back
|
||||
/// pressure applied by `send(_:)` via suspension/resume ensures that the production of values does
|
||||
/// not exceed the consumption of values from iteration. This method suspends after enqueuing the event
|
||||
/// and is resumed when the next call to `next()` on the `Iterator` is made, or when `finish()`/`fail(_:)` is called
|
||||
/// from another Task. As `finish()` and `fail(_:)` induce a terminal state, there is no more need for a back pressure management.
|
||||
/// Those functions do not suspend and will finish all the pending iterations.
|
||||
public final class AsyncThrowingChannel<Element, Failure: Error>: AsyncSequence, @unchecked Sendable {
|
||||
public typealias Element = Element
|
||||
public typealias AsyncIterator = Iterator
|
||||
|
||||
let storage: ChannelStorage<Element, Failure>
|
||||
|
||||
public init() {
|
||||
self.storage = ChannelStorage()
|
||||
}
|
||||
|
||||
/// Sends an element to an awaiting iteration. This function will resume when the next call to `next()` is made
|
||||
/// or when a call to `finish()` or `fail` is made from another task.
|
||||
/// If the channel is already finished then this returns immediately.
|
||||
/// If the task is cancelled, this function will resume without sending the element.
|
||||
/// Other sending operations from other tasks will remain active.
|
||||
public func send(_ element: Element) async {
|
||||
await self.storage.send(element: element)
|
||||
}
|
||||
|
||||
/// Sends an error to all awaiting iterations.
|
||||
/// All subsequent calls to `next(_:)` will resume immediately.
|
||||
public func fail(_ error: Error) where Failure == Error {
|
||||
self.storage.finish(error: error)
|
||||
}
|
||||
|
||||
/// Immediately resumes all the suspended operations.
|
||||
/// All subsequent calls to `next(_:)` will resume immediately.
|
||||
public func finish() {
|
||||
self.storage.finish()
|
||||
}
|
||||
|
||||
public func makeAsyncIterator() -> Iterator {
|
||||
Iterator(storage: self.storage)
|
||||
}
|
||||
|
||||
public struct Iterator: AsyncIteratorProtocol {
|
||||
let storage: ChannelStorage<Element, Failure>
|
||||
|
||||
public mutating func next() async throws -> Element? {
|
||||
try await self.storage.next()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,344 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
@_implementationOnly import OrderedCollections
|
||||
|
||||
struct ChannelStateMachine<Element, Failure: Error>: Sendable {
|
||||
private struct SuspendedProducer: Hashable {
|
||||
let id: UInt64
|
||||
let continuation: UnsafeContinuation<Void, Never>?
|
||||
let element: Element?
|
||||
|
||||
func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(self.id)
|
||||
}
|
||||
|
||||
static func == (_ lhs: SuspendedProducer, _ rhs: SuspendedProducer) -> Bool {
|
||||
return lhs.id == rhs.id
|
||||
}
|
||||
|
||||
static func placeHolder(id: UInt64) -> SuspendedProducer {
|
||||
SuspendedProducer(id: id, continuation: nil, element: nil)
|
||||
}
|
||||
}
|
||||
|
||||
private struct SuspendedConsumer: Hashable {
|
||||
let id: UInt64
|
||||
let continuation: UnsafeContinuation<Element?, any Error>?
|
||||
|
||||
func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(self.id)
|
||||
}
|
||||
|
||||
static func == (_ lhs: SuspendedConsumer, _ rhs: SuspendedConsumer) -> Bool {
|
||||
return lhs.id == rhs.id
|
||||
}
|
||||
|
||||
static func placeHolder(id: UInt64) -> SuspendedConsumer {
|
||||
SuspendedConsumer(id: id, continuation: nil)
|
||||
}
|
||||
}
|
||||
|
||||
private enum Termination {
|
||||
case finished
|
||||
case failed(Error)
|
||||
}
|
||||
|
||||
private enum State {
|
||||
case channeling(
|
||||
suspendedProducers: OrderedSet<SuspendedProducer>,
|
||||
cancelledProducers: Set<SuspendedProducer>,
|
||||
suspendedConsumers: OrderedSet<SuspendedConsumer>,
|
||||
cancelledConsumers: Set<SuspendedConsumer>
|
||||
)
|
||||
case terminated(Termination)
|
||||
}
|
||||
|
||||
private var state: State = .channeling(suspendedProducers: [], cancelledProducers: [], suspendedConsumers: [], cancelledConsumers: [])
|
||||
|
||||
enum SendAction {
|
||||
case resumeConsumer(continuation: UnsafeContinuation<Element?, any Error>?)
|
||||
case suspend
|
||||
}
|
||||
|
||||
mutating func send() -> SendAction {
|
||||
switch self.state {
|
||||
case .channeling(_, _, let suspendedConsumers, _) where suspendedConsumers.isEmpty:
|
||||
// we are idle or waiting for consumers, we have to suspend the producer
|
||||
return .suspend
|
||||
|
||||
case .channeling(let suspendedProducers, let cancelledProducers, var suspendedConsumers, let cancelledConsumers):
|
||||
// we are waiting for producers, we can resume the first available consumer
|
||||
let suspendedConsumer = suspendedConsumers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeConsumer(continuation: suspendedConsumer.continuation)
|
||||
|
||||
case .terminated:
|
||||
return .resumeConsumer(continuation: nil)
|
||||
}
|
||||
}
|
||||
|
||||
enum SendSuspendedAction {
|
||||
case resumeProducer
|
||||
case resumeProducerAndConsumer(continuation: UnsafeContinuation<Element?, any Error>?)
|
||||
}
|
||||
|
||||
mutating func sendSuspended(
|
||||
continuation: UnsafeContinuation<Void, Never>,
|
||||
element: Element,
|
||||
producerID: UInt64
|
||||
) -> SendSuspendedAction? {
|
||||
switch self.state {
|
||||
case .channeling(var suspendedProducers, var cancelledProducers, var suspendedConsumers, let cancelledConsumers):
|
||||
let suspendedProducer = SuspendedProducer(id: producerID, continuation: continuation, element: element)
|
||||
if let _ = cancelledProducers.remove(suspendedProducer) {
|
||||
// the producer was already cancelled, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducer
|
||||
}
|
||||
|
||||
if suspendedConsumers.isEmpty {
|
||||
// we are idle or waiting for consumers
|
||||
// we stack the incoming producer in a suspended state
|
||||
suspendedProducers.append(suspendedProducer)
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
} else {
|
||||
// we are waiting for producers
|
||||
// we resume the first consumer
|
||||
let suspendedConsumer = suspendedConsumers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducerAndConsumer(continuation: suspendedConsumer.continuation)
|
||||
}
|
||||
|
||||
case .terminated:
|
||||
return .resumeProducer
|
||||
}
|
||||
}
|
||||
|
||||
enum SendCancelledAction {
|
||||
case none
|
||||
case resumeProducer(continuation: UnsafeContinuation<Void, Never>?)
|
||||
}
|
||||
|
||||
mutating func sendCancelled(producerID: UInt64) -> SendCancelledAction {
|
||||
switch self.state {
|
||||
case .channeling(var suspendedProducers, var cancelledProducers, let suspendedConsumers, let cancelledConsumers):
|
||||
// the cancelled producer might be part of the waiting list
|
||||
let placeHolder = SuspendedProducer.placeHolder(id: producerID)
|
||||
|
||||
if let removed = suspendedProducers.remove(placeHolder) {
|
||||
// the producer was cancelled after being added to the suspended ones, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducer(continuation: removed.continuation)
|
||||
}
|
||||
|
||||
// the producer was cancelled before being added to the suspended ones
|
||||
cancelledProducers.update(with: placeHolder)
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
|
||||
case .terminated:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
enum FinishAction {
|
||||
case none
|
||||
case resumeProducersAndConsumers(
|
||||
producerSontinuations: [UnsafeContinuation<Void, Never>?],
|
||||
consumerContinuations: [UnsafeContinuation<Element?, any Error>?]
|
||||
)
|
||||
}
|
||||
|
||||
mutating func finish(error: Failure?) -> FinishAction {
|
||||
switch self.state {
|
||||
case .channeling(let suspendedProducers, _, let suspendedConsumers, _):
|
||||
// no matter if we are idle, waiting for producers or waiting for consumers, we resume every thing that is suspended
|
||||
if let error {
|
||||
if suspendedConsumers.isEmpty {
|
||||
self.state = .terminated(.failed(error))
|
||||
} else {
|
||||
self.state = .terminated(.finished)
|
||||
}
|
||||
} else {
|
||||
self.state = .terminated(.finished)
|
||||
}
|
||||
return .resumeProducersAndConsumers(
|
||||
producerSontinuations: suspendedProducers.map { $0.continuation },
|
||||
consumerContinuations: suspendedConsumers.map { $0.continuation }
|
||||
)
|
||||
|
||||
case .terminated:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
|
||||
enum NextAction {
|
||||
case resumeProducer(continuation: UnsafeContinuation<Void, Never>?, result: Result<Element?, Error>)
|
||||
case suspend
|
||||
}
|
||||
|
||||
mutating func next() -> NextAction {
|
||||
switch self.state {
|
||||
case .channeling(let suspendedProducers, _, _, _) where suspendedProducers.isEmpty:
|
||||
// we are idle or waiting for producers, we must suspend
|
||||
return .suspend
|
||||
|
||||
case .channeling(var suspendedProducers, let cancelledProducers, let suspendedConsumers, let cancelledConsumers):
|
||||
// we are waiting for consumers, we can resume the first awaiting producer
|
||||
let suspendedProducer = suspendedProducers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducer(
|
||||
continuation: suspendedProducer.continuation,
|
||||
result: .success(suspendedProducer.element)
|
||||
)
|
||||
|
||||
case .terminated(.failed(let error)):
|
||||
self.state = .terminated(.finished)
|
||||
return .resumeProducer(continuation: nil, result: .failure(error))
|
||||
|
||||
case .terminated:
|
||||
return .resumeProducer(continuation: nil, result: .success(nil))
|
||||
}
|
||||
}
|
||||
|
||||
enum NextSuspendedAction {
|
||||
case resumeConsumer(element: Element?)
|
||||
case resumeConsumerWithError(error: Error)
|
||||
case resumeProducerAndConsumer(continuation: UnsafeContinuation<Void, Never>?, element: Element?)
|
||||
}
|
||||
|
||||
mutating func nextSuspended(
|
||||
continuation: UnsafeContinuation<Element?, any Error>,
|
||||
consumerID: UInt64
|
||||
) -> NextSuspendedAction? {
|
||||
switch self.state {
|
||||
case .channeling(var suspendedProducers, let cancelledProducers, var suspendedConsumers, var cancelledConsumers):
|
||||
let suspendedConsumer = SuspendedConsumer(id: consumerID, continuation: continuation)
|
||||
if let _ = cancelledConsumers.remove(suspendedConsumer) {
|
||||
// the consumer was already cancelled, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeConsumer(element: nil)
|
||||
}
|
||||
|
||||
if suspendedProducers.isEmpty {
|
||||
// we are idle or waiting for producers
|
||||
// we stack the incoming consumer in a suspended state
|
||||
suspendedConsumers.append(suspendedConsumer)
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
} else {
|
||||
// we are waiting for consumers
|
||||
// we resume the first producer
|
||||
let suspendedProducer = suspendedProducers.removeFirst()
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeProducerAndConsumer(
|
||||
continuation: suspendedProducer.continuation,
|
||||
element: suspendedProducer.element
|
||||
)
|
||||
}
|
||||
|
||||
case .terminated(.finished):
|
||||
return .resumeConsumer(element: nil)
|
||||
|
||||
case .terminated(.failed(let error)):
|
||||
self.state = .terminated(.finished)
|
||||
return .resumeConsumerWithError(error: error)
|
||||
}
|
||||
}
|
||||
|
||||
enum NextCancelledAction {
|
||||
case none
|
||||
case resumeConsumer(continuation: UnsafeContinuation<Element?, any Error>?)
|
||||
}
|
||||
|
||||
mutating func nextCancelled(consumerID: UInt64) -> NextCancelledAction {
|
||||
switch self.state {
|
||||
case .channeling(let suspendedProducers, let cancelledProducers, var suspendedConsumers, var cancelledConsumers):
|
||||
// the cancelled consumer might be part of the suspended ones
|
||||
let placeHolder = SuspendedConsumer.placeHolder(id: consumerID)
|
||||
|
||||
if let removed = suspendedConsumers.remove(placeHolder) {
|
||||
// the consumer was cancelled after being added to the suspended ones, we resume it
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .resumeConsumer(continuation: removed.continuation)
|
||||
}
|
||||
|
||||
// the consumer was cancelled before being added to the suspended ones
|
||||
cancelledConsumers.update(with: placeHolder)
|
||||
self.state = .channeling(
|
||||
suspendedProducers: suspendedProducers,
|
||||
cancelledProducers: cancelledProducers,
|
||||
suspendedConsumers: suspendedConsumers,
|
||||
cancelledConsumers: cancelledConsumers
|
||||
)
|
||||
return .none
|
||||
|
||||
case .terminated:
|
||||
return .none
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
struct ChannelStorage<Element, Failure: Error>: Sendable {
|
||||
private let stateMachine: ManagedCriticalState<ChannelStateMachine<Element, Failure>>
|
||||
private let ids = ManagedCriticalState<UInt64>(0)
|
||||
|
||||
init() {
|
||||
self.stateMachine = ManagedCriticalState(ChannelStateMachine())
|
||||
}
|
||||
|
||||
func generateId() -> UInt64 {
|
||||
self.ids.withCriticalRegion { ids in
|
||||
defer { ids &+= 1 }
|
||||
return ids
|
||||
}
|
||||
}
|
||||
|
||||
func send(element: Element) async {
|
||||
// check if a suspension is needed
|
||||
let shouldExit = self.stateMachine.withCriticalRegion { stateMachine -> Bool in
|
||||
let action = stateMachine.send()
|
||||
|
||||
switch action {
|
||||
case .suspend:
|
||||
// the element has not been delivered because no consumer available, we must suspend
|
||||
return false
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: element)
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
if shouldExit {
|
||||
return
|
||||
}
|
||||
|
||||
let producerID = self.generateId()
|
||||
|
||||
await withTaskCancellationHandler {
|
||||
// a suspension is needed
|
||||
await withUnsafeContinuation { (continuation: UnsafeContinuation<Void, Never>) in
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.sendSuspended(continuation: continuation, element: element, producerID: producerID)
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducer:
|
||||
continuation.resume()
|
||||
case .resumeProducerAndConsumer(let consumerContinuation):
|
||||
continuation.resume()
|
||||
consumerContinuation?.resume(returning: element)
|
||||
}
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.sendCancelled(producerID: producerID)
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducer(let continuation):
|
||||
continuation?.resume()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func finish(error: Failure? = nil) {
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.finish(error: error)
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeProducersAndConsumers(let producerContinuations, let consumerContinuations):
|
||||
producerContinuations.forEach { $0?.resume() }
|
||||
if let error {
|
||||
consumerContinuations.forEach { $0?.resume(throwing: error) }
|
||||
} else {
|
||||
consumerContinuations.forEach { $0?.resume(returning: nil) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func next() async throws -> Element? {
|
||||
let (shouldExit, result) = self.stateMachine.withCriticalRegion { stateMachine -> (Bool, Result<Element?, Error>?) in
|
||||
let action = stateMachine.next()
|
||||
|
||||
switch action {
|
||||
case .suspend:
|
||||
return (false, nil)
|
||||
case .resumeProducer(let producerContinuation, let result):
|
||||
producerContinuation?.resume()
|
||||
return (true, result)
|
||||
}
|
||||
}
|
||||
|
||||
if shouldExit {
|
||||
return try result?._rethrowGet()
|
||||
}
|
||||
|
||||
let consumerID = self.generateId()
|
||||
|
||||
return try await withTaskCancellationHandler {
|
||||
try await withUnsafeThrowingContinuation { (continuation: UnsafeContinuation<Element?, any Error>) in
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.nextSuspended(
|
||||
continuation: continuation,
|
||||
consumerID: consumerID
|
||||
)
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let element):
|
||||
continuation.resume(returning: element)
|
||||
case .resumeConsumerWithError(let error):
|
||||
continuation.resume(throwing: error)
|
||||
case .resumeProducerAndConsumer(let producerContinuation, let element):
|
||||
producerContinuation?.resume()
|
||||
continuation.resume(returning: element)
|
||||
}
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.nextCancelled(consumerID: consumerID)
|
||||
|
||||
switch action {
|
||||
case .none:
|
||||
break
|
||||
case .resumeConsumer(let continuation):
|
||||
continuation?.resume(returning: nil)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -585,7 +585,9 @@ struct CombineLatestStateMachine<
|
||||
mutating func cancelled() -> CancelledAction? {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received cancelled()")
|
||||
state = .finished
|
||||
|
||||
return .none
|
||||
|
||||
case .waitingForDemand(let task, let upstreams, _):
|
||||
// The downstream task got cancelled so we need to cancel our upstream Task
|
||||
|
||||
@@ -583,9 +583,8 @@ struct DebounceStateMachine<Base: AsyncSequence, C: Clock> {
|
||||
mutating func cancelled() -> CancelledAction? {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
// Since we are transitioning to `merging` before we return from `makeAsyncIterator`
|
||||
// this can never happen
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received cancelled()")
|
||||
state = .finished
|
||||
return .none
|
||||
|
||||
case .waitingForDemand:
|
||||
// We got cancelled before we event got any demand. This can happen if a cancelled task
|
||||
|
||||
@@ -37,7 +37,8 @@ internal struct Lock {
|
||||
#if canImport(Darwin)
|
||||
platformLock.initialize(to: os_unfair_lock())
|
||||
#elseif canImport(Glibc)
|
||||
pthread_mutex_init(platformLock, nil)
|
||||
let result = pthread_mutex_init(platformLock, nil)
|
||||
precondition(result == 0, "pthread_mutex_init failed")
|
||||
#elseif canImport(WinSDK)
|
||||
InitializeSRWLock(platformLock)
|
||||
#endif
|
||||
@@ -45,7 +46,8 @@ internal struct Lock {
|
||||
|
||||
fileprivate static func deinitialize(_ platformLock: PlatformLock) {
|
||||
#if canImport(Glibc)
|
||||
pthread_mutex_destroy(platformLock)
|
||||
let result = pthread_mutex_destroy(platformLock)
|
||||
precondition(result == 0, "pthread_mutex_destroy failed")
|
||||
#endif
|
||||
platformLock.deinitialize(count: 1)
|
||||
}
|
||||
@@ -64,7 +66,8 @@ internal struct Lock {
|
||||
#if canImport(Darwin)
|
||||
os_unfair_lock_unlock(platformLock)
|
||||
#elseif canImport(Glibc)
|
||||
pthread_mutex_unlock(platformLock)
|
||||
let result = pthread_mutex_unlock(platformLock)
|
||||
precondition(result == 0, "pthread_mutex_unlock failed")
|
||||
#elseif canImport(WinSDK)
|
||||
ReleaseSRWLockExclusive(platformLock)
|
||||
#endif
|
||||
|
||||
@@ -465,9 +465,11 @@ struct MergeStateMachine<
|
||||
mutating func cancelled() -> CancelledAction {
|
||||
switch state {
|
||||
case .initial:
|
||||
// Since we are transitioning to `merging` before we return from `makeAsyncIterator`
|
||||
// this can never happen
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received cancelled()")
|
||||
// Since we are only transitioning to merging when the task is started we
|
||||
// can be cancelled already.
|
||||
state = .finished
|
||||
|
||||
return .none
|
||||
|
||||
case let .merging(task, _, upstreamContinuations, _, .some(downstreamContinuation)):
|
||||
// The downstream Task got cancelled so we need to cancel our upstream Task
|
||||
|
||||
@@ -460,7 +460,9 @@ struct ZipStateMachine<
|
||||
mutating func cancelled() -> CancelledAction? {
|
||||
switch self.state {
|
||||
case .initial:
|
||||
preconditionFailure("Internal inconsistency current state \(self.state) and received cancelled()")
|
||||
state = .finished
|
||||
|
||||
return .none
|
||||
|
||||
case .waitingForDemand(let task, let upstreams):
|
||||
// The downstream task got cancelled so we need to cancel our upstream Task
|
||||
|
||||
@@ -165,7 +165,7 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
|
||||
}
|
||||
|
||||
group.addTask {
|
||||
var base1Iterator = base2.makeAsyncIterator()
|
||||
var base2Iterator = base2.makeAsyncIterator()
|
||||
|
||||
while true {
|
||||
// We are creating a continuation before requesting the next
|
||||
@@ -188,7 +188,7 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
|
||||
}
|
||||
}
|
||||
|
||||
if let element2 = try await base1Iterator.next() {
|
||||
if let element2 = try await base2Iterator.next() {
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.elementProduced((nil, element2, nil))
|
||||
|
||||
@@ -226,7 +226,7 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
|
||||
|
||||
if let base3 = base3 {
|
||||
group.addTask {
|
||||
var base1Iterator = base3.makeAsyncIterator()
|
||||
var base3Iterator = base3.makeAsyncIterator()
|
||||
|
||||
while true {
|
||||
// We are creating a continuation before requesting the next
|
||||
@@ -249,7 +249,7 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
|
||||
}
|
||||
}
|
||||
|
||||
if let element3 = try await base1Iterator.next() {
|
||||
if let element3 = try await base3Iterator.next() {
|
||||
self.stateMachine.withCriticalRegion { stateMachine in
|
||||
let action = stateMachine.elementProduced((nil, nil, element3))
|
||||
|
||||
|
||||
@@ -14,6 +14,32 @@ import AsyncAlgorithms
|
||||
|
||||
#if canImport(Darwin)
|
||||
final class TestThroughput: XCTestCase {
|
||||
func test_channel() async {
|
||||
await measureChannelThroughput(output: 1)
|
||||
}
|
||||
func test_throwingChannel() async {
|
||||
await measureThrowingChannelThroughput(output: 1)
|
||||
}
|
||||
func test_buffer_bounded() async {
|
||||
await measureSequenceThroughput(output: 1) {
|
||||
$0.buffer(policy: .bounded(5))
|
||||
}
|
||||
}
|
||||
func test_buffer_unbounded() async {
|
||||
await measureSequenceThroughput(output: 1) {
|
||||
$0.buffer(policy: .unbounded)
|
||||
}
|
||||
}
|
||||
func test_buffer_bufferingNewest() async {
|
||||
await measureSequenceThroughput(output: 1) {
|
||||
$0.buffer(policy: .bufferingLatest(5))
|
||||
}
|
||||
}
|
||||
func test_buffer_bufferingOldest() async {
|
||||
await measureSequenceThroughput(output: 1) {
|
||||
$0.buffer(policy: .bufferingOldest(5))
|
||||
}
|
||||
}
|
||||
func test_chain2() async {
|
||||
await measureSequenceThroughput(firstOutput: 1, secondOutput: 2) {
|
||||
chain($0, $1)
|
||||
|
||||
@@ -56,6 +56,64 @@ final class _ThroughputMetric: NSObject, XCTMetric, @unchecked Sendable {
|
||||
}
|
||||
|
||||
extension XCTestCase {
|
||||
public func measureChannelThroughput<Output>(output: @escaping @autoclosure () -> Output) async {
|
||||
let metric = _ThroughputMetric()
|
||||
let sampleTime: Double = 0.1
|
||||
|
||||
measure(metrics: [metric]) {
|
||||
let channel = AsyncChannel<Output>()
|
||||
|
||||
let exp = self.expectation(description: "Finished")
|
||||
let iterTask = Task<Int, Error> {
|
||||
var eventCount = 0
|
||||
for try await _ in channel {
|
||||
eventCount += 1
|
||||
}
|
||||
metric.eventCount = eventCount
|
||||
exp.fulfill()
|
||||
return eventCount
|
||||
}
|
||||
let sendTask = Task<Void, Never> {
|
||||
while !Task.isCancelled {
|
||||
await channel.send(output())
|
||||
}
|
||||
}
|
||||
usleep(UInt32(sampleTime * Double(USEC_PER_SEC)))
|
||||
iterTask.cancel()
|
||||
sendTask.cancel()
|
||||
self.wait(for: [exp], timeout: sampleTime * 2)
|
||||
}
|
||||
}
|
||||
|
||||
public func measureThrowingChannelThroughput<Output>(output: @escaping @autoclosure () -> Output) async {
|
||||
let metric = _ThroughputMetric()
|
||||
let sampleTime: Double = 0.1
|
||||
|
||||
measure(metrics: [metric]) {
|
||||
let channel = AsyncThrowingChannel<Output, Error>()
|
||||
|
||||
let exp = self.expectation(description: "Finished")
|
||||
let iterTask = Task<Int, Error> {
|
||||
var eventCount = 0
|
||||
for try await _ in channel {
|
||||
eventCount += 1
|
||||
}
|
||||
metric.eventCount = eventCount
|
||||
exp.fulfill()
|
||||
return eventCount
|
||||
}
|
||||
let sendTask = Task<Void, Never> {
|
||||
while !Task.isCancelled {
|
||||
await channel.send(output())
|
||||
}
|
||||
}
|
||||
usleep(UInt32(sampleTime * Double(USEC_PER_SEC)))
|
||||
iterTask.cancel()
|
||||
sendTask.cancel()
|
||||
self.wait(for: [exp], timeout: sampleTime * 2)
|
||||
}
|
||||
}
|
||||
|
||||
public func measureSequenceThroughput<S: AsyncSequence, Output>( output: @autoclosure () -> Output, _ sequenceBuilder: (InfiniteAsyncSequence<Output>) -> S) async where S: Sendable {
|
||||
let metric = _ThroughputMetric()
|
||||
let sampleTime: Double = 0.1
|
||||
|
||||
@@ -13,219 +13,102 @@ import XCTest
|
||||
import AsyncAlgorithms
|
||||
|
||||
final class TestBuffer: XCTestCase {
|
||||
func test_buffering() async {
|
||||
var gated = GatedSequence([1, 2, 3, 4, 5])
|
||||
let sequence = gated.buffer(policy: .unbounded)
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
|
||||
gated.advance()
|
||||
func test_given_a_base_sequence_when_buffering_with_unbounded_then_the_buffer_is_filled_in() async {
|
||||
// Given
|
||||
var base = GatedSequence([1, 2, 3, 4, 5])
|
||||
let buffered = base.buffer(policy: .unbounded)
|
||||
var iterator = buffered.makeAsyncIterator()
|
||||
|
||||
// When
|
||||
base.advance()
|
||||
|
||||
// Then
|
||||
var value = await iterator.next()
|
||||
XCTAssertEqual(value, 1)
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
|
||||
// When
|
||||
base.advance()
|
||||
base.advance()
|
||||
base.advance()
|
||||
|
||||
// Then
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, 2)
|
||||
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, 3)
|
||||
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, 4)
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
|
||||
// When
|
||||
base.advance()
|
||||
base.advance()
|
||||
|
||||
// Then
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, 5)
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, nil)
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, nil)
|
||||
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertEqual(value, pastEnd)
|
||||
}
|
||||
|
||||
func test_buffering_withError() async {
|
||||
func test_given_a_failable_base_sequence_when_buffering_with_unbounded_then_the_failure_is_forwarded() async {
|
||||
// Given
|
||||
var gated = GatedSequence([1, 2, 3, 4, 5, 6, 7])
|
||||
let gated_map = gated.map { try throwOn(3, $0) }
|
||||
let sequence = gated_map.buffer(policy: .unbounded)
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
let base = gated.map { try throwOn(3, $0) }
|
||||
let buffered = base.buffer(policy: .unbounded)
|
||||
var iterator = buffered.makeAsyncIterator()
|
||||
|
||||
// When
|
||||
gated.advance()
|
||||
|
||||
// Then
|
||||
var value = try! await iterator.next()
|
||||
XCTAssertEqual(value, 1)
|
||||
|
||||
// When
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
|
||||
// Then
|
||||
value = try! await iterator.next()
|
||||
XCTAssertEqual(value, 2)
|
||||
|
||||
// When
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
|
||||
// Then
|
||||
do {
|
||||
value = try await iterator.next()
|
||||
XCTFail("next() should have thrown.")
|
||||
} catch { }
|
||||
|
||||
value = try! await iterator.next()
|
||||
XCTAssertNil(value)
|
||||
|
||||
value = try! await iterator.next()
|
||||
XCTAssertNil(value)
|
||||
|
||||
value = try! await iterator.next()
|
||||
XCTAssertNil(value)
|
||||
|
||||
value = try! await iterator.next()
|
||||
XCTAssertNil(value)
|
||||
|
||||
value = try! await iterator.next()
|
||||
XCTAssertNil(value)
|
||||
}
|
||||
|
||||
func test_buffer_delegation() async {
|
||||
actor BufferDelegate: AsyncBuffer {
|
||||
var buffer = [Int]()
|
||||
var pushed = [Int]()
|
||||
|
||||
func push(_ element: Int) async {
|
||||
buffer.append(element)
|
||||
pushed.append(element)
|
||||
}
|
||||
|
||||
func pop() async -> Int? {
|
||||
if buffer.count > 0 {
|
||||
return buffer.removeFirst()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
} catch {
|
||||
XCTAssert(error is Failure)
|
||||
}
|
||||
let delegate = BufferDelegate()
|
||||
var gated = GatedSequence([1, 2, 3, 4, 5])
|
||||
let sequence = gated.buffer {
|
||||
delegate
|
||||
}
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
|
||||
gated.advance()
|
||||
var value = await iterator.next()
|
||||
var pushed = await delegate.pushed
|
||||
XCTAssertEqual(pushed, [1])
|
||||
XCTAssertEqual(value, 1)
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, 2)
|
||||
value = await iterator.next()
|
||||
pushed = await delegate.pushed
|
||||
XCTAssertEqual(value, 3)
|
||||
value = await iterator.next()
|
||||
pushed = await delegate.pushed
|
||||
XCTAssertEqual(pushed, [1, 2, 3, 4])
|
||||
XCTAssertEqual(value, 4)
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
value = await iterator.next()
|
||||
pushed = await delegate.pushed
|
||||
XCTAssertEqual(pushed, [1, 2, 3, 4, 5])
|
||||
XCTAssertEqual(value, 5)
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, nil)
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, nil)
|
||||
|
||||
var pastFailure = try! await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
|
||||
pastFailure = try! await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
|
||||
pastFailure = try! await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
|
||||
pastFailure = try! await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
|
||||
pastFailure = try! await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
}
|
||||
|
||||
func test_delegatedBuffer_withError() async {
|
||||
actor BufferDelegate: AsyncBuffer {
|
||||
var buffer = [Int]()
|
||||
var pushed = [Int]()
|
||||
|
||||
func push(_ element: Int) async {
|
||||
buffer.append(element)
|
||||
pushed.append(element)
|
||||
}
|
||||
|
||||
func pop() async throws -> Int? {
|
||||
if buffer.count > 0 {
|
||||
let value = buffer.removeFirst()
|
||||
if value == 3 {
|
||||
throw Failure()
|
||||
}
|
||||
return value
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
let delegate = BufferDelegate()
|
||||
|
||||
var gated = GatedSequence([1, 2, 3, 4, 5, 6, 7])
|
||||
let sequence = gated.buffer { delegate }
|
||||
var iterator = sequence.makeAsyncIterator()
|
||||
|
||||
gated.advance()
|
||||
var value = try! await iterator.next()
|
||||
XCTAssertEqual(value, 1)
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
value = try! await iterator.next()
|
||||
XCTAssertEqual(value, 2)
|
||||
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
do {
|
||||
value = try await iterator.next()
|
||||
XCTFail("next() should have thrown.")
|
||||
} catch { }
|
||||
|
||||
value = try! await iterator.next()
|
||||
XCTAssertNil(value)
|
||||
|
||||
value = try! await iterator.next()
|
||||
XCTAssertNil(value)
|
||||
|
||||
value = try! await iterator.next()
|
||||
XCTAssertNil(value)
|
||||
|
||||
value = try! await iterator.next()
|
||||
XCTAssertNil(value)
|
||||
|
||||
value = try! await iterator.next()
|
||||
XCTAssertNil(value)
|
||||
}
|
||||
|
||||
func test_byteBuffer() async {
|
||||
actor ByteBuffer: AsyncBuffer {
|
||||
var buffer: [UInt8]?
|
||||
|
||||
func push(_ element: UInt8) async {
|
||||
if buffer == nil {
|
||||
buffer = [UInt8]()
|
||||
}
|
||||
buffer?.append(element)
|
||||
}
|
||||
|
||||
func pop() async -> [UInt8]? {
|
||||
defer { buffer = nil }
|
||||
return buffer
|
||||
}
|
||||
}
|
||||
|
||||
var data = Data()
|
||||
for _ in 0..<4096 {
|
||||
data.append(UInt8.random(in: 0..<UInt8.max))
|
||||
}
|
||||
let buffered = data.async.buffer {
|
||||
ByteBuffer()
|
||||
}
|
||||
var collected = Data()
|
||||
for await segment in buffered {
|
||||
collected.append(contentsOf: segment)
|
||||
}
|
||||
XCTAssertEqual(data, collected)
|
||||
}
|
||||
|
||||
func test_bufferingOldest() async {
|
||||
func test_given_a_base_sequence_when_bufferingOldest_then_the_policy_is_applied() async {
|
||||
validate {
|
||||
"X-12- 34- 5 |"
|
||||
$0.inputs[0].buffer(policy: .bufferingOldest(2))
|
||||
@@ -233,7 +116,15 @@ final class TestBuffer: XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
func test_bufferingOldest_noDrops() async {
|
||||
func test_given_a_base_sequence_when_bufferingOldest_with_0_limit_then_the_policy_is_transparent() async {
|
||||
validate {
|
||||
"X-12- 34- 5 |"
|
||||
$0.inputs[0].buffer(policy: .bufferingOldest(0))
|
||||
"X-12- 34- 5 |"
|
||||
}
|
||||
}
|
||||
|
||||
func test_given_a_base_sequence_when_bufferingOldest_at_slow_pace_then_no_element_is_dropped() async {
|
||||
validate {
|
||||
"X-12 3 4 5 |"
|
||||
$0.inputs[0].buffer(policy: .bufferingOldest(2))
|
||||
@@ -241,7 +132,7 @@ final class TestBuffer: XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
func test_bufferingOldest_error() async {
|
||||
func test_given_a_failable_base_sequence_when_bufferingOldest_then_the_failure_is_forwarded() async {
|
||||
validate {
|
||||
"X-12345^"
|
||||
$0.inputs[0].buffer(policy: .bufferingOldest(2))
|
||||
@@ -249,27 +140,190 @@ final class TestBuffer: XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
func test_bufferingNewest() async {
|
||||
func test_given_a_base_sequence_when_bufferingNewest_then_the_policy_is_applied() async {
|
||||
validate {
|
||||
"X-12- 34 -5|"
|
||||
$0.inputs[0].buffer(policy: .bufferingNewest(2))
|
||||
$0.inputs[0].buffer(policy: .bufferingLatest(2))
|
||||
"X,,,[1,],,[3,],[4,][5,]|"
|
||||
}
|
||||
}
|
||||
|
||||
func test_bufferingNewest_noDrops() async {
|
||||
func test_given_a_base_sequence_when_bufferingNewest_with_limit_0_then_the_policy_is_transparent() async {
|
||||
validate {
|
||||
"X-12- 34 -5|"
|
||||
$0.inputs[0].buffer(policy: .bufferingLatest(0))
|
||||
"X-12- 34 -5|"
|
||||
}
|
||||
}
|
||||
|
||||
func test_given_a_base_sequence_when_bufferingNewest_at_slow_pace_then_no_element_is_dropped() async {
|
||||
validate {
|
||||
"X-12 3 4 5 |"
|
||||
$0.inputs[0].buffer(policy: .bufferingNewest(2))
|
||||
$0.inputs[0].buffer(policy: .bufferingLatest(2))
|
||||
"X,,[1,][2,][3,][45]|"
|
||||
}
|
||||
}
|
||||
|
||||
func test_bufferingNewest_error() async {
|
||||
func test_given_a_failable_base_sequence_when_bufferingNewest_then_the_failure_is_forwarded() async {
|
||||
validate {
|
||||
"X-12345^"
|
||||
$0.inputs[0].buffer(policy: .bufferingNewest(2))
|
||||
$0.inputs[0].buffer(policy: .bufferingLatest(2))
|
||||
"X,,,,,,[45^]"
|
||||
}
|
||||
}
|
||||
|
||||
func test_given_a_buffered_with_unbounded_sequence_when_cancelling_consumer_then_the_iteration_finishes_and_the_base_is_cancelled() async {
|
||||
// Given
|
||||
let buffered = Indefinite(value: 1).async.buffer(policy: .unbounded)
|
||||
|
||||
let finished = expectation(description: "finished")
|
||||
let iterated = expectation(description: "iterated")
|
||||
|
||||
let task = Task {
|
||||
var firstIteration = false
|
||||
for await _ in buffered {
|
||||
if !firstIteration {
|
||||
firstIteration = true
|
||||
iterated.fulfill()
|
||||
}
|
||||
}
|
||||
finished.fulfill()
|
||||
}
|
||||
// ensure the task actually starts
|
||||
wait(for: [iterated], timeout: 1.0)
|
||||
|
||||
// When
|
||||
task.cancel()
|
||||
|
||||
// Then
|
||||
wait(for: [finished], timeout: 1.0)
|
||||
}
|
||||
|
||||
func test_given_a_base_sequence_when_buffering_with_bounded_then_the_buffer_is_filled_in_and_suspends() async {
|
||||
// Gicen
|
||||
var base = GatedSequence([1, 2, 3, 4, 5])
|
||||
let buffered = base.buffer(policy: .bounded(2))
|
||||
var iterator = buffered.makeAsyncIterator()
|
||||
|
||||
// When
|
||||
base.advance()
|
||||
|
||||
// Then
|
||||
var value = await iterator.next()
|
||||
XCTAssertEqual(value, 1)
|
||||
|
||||
// When
|
||||
base.advance()
|
||||
base.advance()
|
||||
base.advance()
|
||||
|
||||
// Then
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, 2)
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, 3)
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, 4)
|
||||
|
||||
// When
|
||||
base.advance()
|
||||
base.advance()
|
||||
|
||||
// Then
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, 5)
|
||||
value = await iterator.next()
|
||||
XCTAssertEqual(value, nil)
|
||||
|
||||
let pastEnd = await iterator.next()
|
||||
XCTAssertEqual(value, pastEnd)
|
||||
}
|
||||
|
||||
func test_given_a_failable_base_sequence_when_buffering_with_bounded_then_the_failure_is_forwarded() async {
|
||||
// Given
|
||||
var gated = GatedSequence([1, 2, 3, 4, 5, 6, 7])
|
||||
let base = gated.map { try throwOn(3, $0) }
|
||||
let buffered = base.buffer(policy: .bounded(5))
|
||||
var iterator = buffered.makeAsyncIterator()
|
||||
|
||||
// When
|
||||
gated.advance()
|
||||
|
||||
// Then
|
||||
var value = try! await iterator.next()
|
||||
XCTAssertEqual(value, 1)
|
||||
|
||||
// When
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
|
||||
// Then
|
||||
value = try! await iterator.next()
|
||||
XCTAssertEqual(value, 2)
|
||||
|
||||
// When
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
gated.advance()
|
||||
|
||||
// Then
|
||||
do {
|
||||
value = try await iterator.next()
|
||||
XCTFail("next() should have thrown.")
|
||||
} catch {
|
||||
XCTAssert(error is Failure)
|
||||
}
|
||||
|
||||
var pastFailure = try! await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
|
||||
pastFailure = try! await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
|
||||
pastFailure = try! await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
|
||||
pastFailure = try! await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
|
||||
pastFailure = try! await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
}
|
||||
|
||||
func test_given_a_buffered_bounded_sequence_when_cancelling_consumer_then_the_iteration_finishes_and_the_base_is_cancelled() async {
|
||||
// Given
|
||||
let buffered = Indefinite(value: 1).async.buffer(policy: .bounded(3))
|
||||
|
||||
let finished = expectation(description: "finished")
|
||||
let iterated = expectation(description: "iterated")
|
||||
|
||||
let task = Task {
|
||||
var firstIteration = false
|
||||
for await _ in buffered {
|
||||
if !firstIteration {
|
||||
firstIteration = true
|
||||
iterated.fulfill()
|
||||
}
|
||||
}
|
||||
finished.fulfill()
|
||||
}
|
||||
// ensure the other task actually starts
|
||||
wait(for: [iterated], timeout: 1.0)
|
||||
|
||||
// When
|
||||
task.cancel()
|
||||
|
||||
// Then
|
||||
wait(for: [finished], timeout: 1.0)
|
||||
}
|
||||
|
||||
func test_given_a_base_sequence_when_bounded_with_limit_0_then_the_policy_is_transparent() async {
|
||||
validate {
|
||||
"X-12- 34 -5|"
|
||||
$0.inputs[0].buffer(policy: .bounded(0))
|
||||
"X-12- 34 -5|"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -13,265 +13,164 @@ import XCTest
|
||||
import AsyncAlgorithms
|
||||
|
||||
final class TestChannel: XCTestCase {
|
||||
func test_asyncChannel_delivers_values_when_two_producers_and_two_consumers() async {
|
||||
let (sentFromProducer1, sentFromProducer2) = ("test1", "test2")
|
||||
let expected = Set([sentFromProducer1, sentFromProducer2])
|
||||
func test_asyncChannel_delivers_elements_when_several_producers_and_several_consumers() async {
|
||||
let sents = (1...10)
|
||||
let expected = Set(sents)
|
||||
|
||||
let channel = AsyncChannel<String>()
|
||||
// Given: an AsyncChannel
|
||||
let sut = AsyncChannel<Int>()
|
||||
|
||||
// When: sending elements from tasks in a group
|
||||
Task {
|
||||
await channel.send(sentFromProducer1)
|
||||
await withTaskGroup(of: Void.self) { group in
|
||||
for sent in sents {
|
||||
group.addTask {
|
||||
await sut.send(sent)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Task {
|
||||
await channel.send(sentFromProducer2)
|
||||
}
|
||||
|
||||
let t: Task<String?, Never> = Task {
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
let value = await iterator.next()
|
||||
return value
|
||||
}
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
|
||||
let (collectedFromConsumer1, collectedFromConsumer2) = (await t.value, await iterator.next())
|
||||
let collected = Set([collectedFromConsumer1, collectedFromConsumer2])
|
||||
// When: receiving those elements from tasks in a group
|
||||
let collected = await withTaskGroup(of: Int.self, returning: Set<Int>.self) { group in
|
||||
for _ in sents {
|
||||
group.addTask {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
let received = await iterator.next()
|
||||
return received!
|
||||
}
|
||||
}
|
||||
|
||||
var collected = Set<Int>()
|
||||
for await element in group {
|
||||
collected.update(with: element)
|
||||
}
|
||||
return collected
|
||||
}
|
||||
|
||||
// Then: all elements are sent and received
|
||||
XCTAssertEqual(collected, expected)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_delivers_values_when_two_producers_and_two_consumers() async throws {
|
||||
let (sentFromProducer1, sentFromProducer2) = ("test1", "test2")
|
||||
let expected = Set([sentFromProducer1, sentFromProducer2])
|
||||
|
||||
let channel = AsyncThrowingChannel<String, Error>()
|
||||
Task {
|
||||
await channel.send("test1")
|
||||
}
|
||||
Task {
|
||||
await channel.send("test2")
|
||||
}
|
||||
|
||||
let t: Task<String?, Error> = Task {
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
let value = try await iterator.next()
|
||||
return value
|
||||
}
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
func test_asyncChannel_resumes_producers_and_discards_additional_elements_when_finish_is_called() async {
|
||||
// Given: an AsyncChannel
|
||||
let sut = AsyncChannel<Int>()
|
||||
|
||||
let (collectedFromConsumer1, collectedFromConsumer2) = (try await t.value, try await iterator.next())
|
||||
let collected = Set([collectedFromConsumer1, collectedFromConsumer2])
|
||||
|
||||
XCTAssertEqual(collected, expected)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_throws_and_discards_additional_sent_values_when_fail_is_called() async {
|
||||
let sendImmediatelyResumes = expectation(description: "Send immediately resumes after fail")
|
||||
|
||||
let channel = AsyncThrowingChannel<String, Error>()
|
||||
channel.fail(Failure())
|
||||
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
do {
|
||||
let _ = try await iterator.next()
|
||||
XCTFail("The AsyncThrowingChannel should have thrown")
|
||||
} catch {
|
||||
XCTAssertEqual(error as? Failure, Failure())
|
||||
// Given: 2 suspended send operations
|
||||
let task1 = Task {
|
||||
await sut.send(1)
|
||||
}
|
||||
|
||||
do {
|
||||
let pastFailure = try await iterator.next()
|
||||
XCTAssertNil(pastFailure)
|
||||
} catch {
|
||||
XCTFail("The AsyncThrowingChannel should not fail when failure has already been fired")
|
||||
let task2 = Task {
|
||||
await sut.send(2)
|
||||
}
|
||||
|
||||
await channel.send("send")
|
||||
sendImmediatelyResumes.fulfill()
|
||||
wait(for: [sendImmediatelyResumes], timeout: 1.0)
|
||||
// When: finishing the channel
|
||||
sut.finish()
|
||||
|
||||
// Then: the send operations are resumed
|
||||
_ = await (task1.value, task2.value)
|
||||
|
||||
// When: sending an extra value
|
||||
await sut.send(3)
|
||||
|
||||
// Then: the operation and the iteration are immediately resumed
|
||||
var collected = [Int]()
|
||||
for await element in sut {
|
||||
collected.append(element)
|
||||
}
|
||||
XCTAssertTrue(collected.isEmpty)
|
||||
}
|
||||
|
||||
func test_asyncChannel_ends_alls_iterators_and_discards_additional_sent_values_when_finish_is_called() async {
|
||||
let channel = AsyncChannel<String>()
|
||||
let complete = ManagedCriticalState(false)
|
||||
let finished = expectation(description: "finished")
|
||||
func test_asyncChannel_resumes_consumers_when_finish_is_called() async {
|
||||
// Given: an AsyncChannel
|
||||
let sut = AsyncChannel<Int>()
|
||||
|
||||
Task {
|
||||
channel.finish()
|
||||
complete.withCriticalRegion { $0 = true }
|
||||
finished.fulfill()
|
||||
}
|
||||
|
||||
let valueFromConsumer1 = ManagedCriticalState<String?>(nil)
|
||||
let valueFromConsumer2 = ManagedCriticalState<String?>(nil)
|
||||
|
||||
let received = expectation(description: "received")
|
||||
received.expectedFulfillmentCount = 2
|
||||
|
||||
let pastEnd = expectation(description: "pastEnd")
|
||||
pastEnd.expectedFulfillmentCount = 2
|
||||
|
||||
Task {
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
let ending = await iterator.next()
|
||||
valueFromConsumer1.withCriticalRegion { $0 = ending }
|
||||
received.fulfill()
|
||||
let item = await iterator.next()
|
||||
XCTAssertNil(item)
|
||||
pastEnd.fulfill()
|
||||
}
|
||||
|
||||
Task {
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
let ending = await iterator.next()
|
||||
valueFromConsumer2.withCriticalRegion { $0 = ending }
|
||||
received.fulfill()
|
||||
let item = await iterator.next()
|
||||
XCTAssertNil(item)
|
||||
pastEnd.fulfill()
|
||||
}
|
||||
|
||||
wait(for: [finished, received], timeout: 1.0)
|
||||
|
||||
XCTAssertTrue(complete.withCriticalRegion { $0 })
|
||||
XCTAssertEqual(valueFromConsumer1.withCriticalRegion { $0 }, nil)
|
||||
XCTAssertEqual(valueFromConsumer2.withCriticalRegion { $0 }, nil)
|
||||
|
||||
wait(for: [pastEnd], timeout: 1.0)
|
||||
let additionalSend = expectation(description: "additional send")
|
||||
Task {
|
||||
await channel.send("test")
|
||||
additionalSend.fulfill()
|
||||
}
|
||||
wait(for: [additionalSend], timeout: 1.0)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_ends_alls_iterators_and_discards_additional_sent_values_when_finish_is_called() async {
|
||||
let channel = AsyncThrowingChannel<String, Error>()
|
||||
let complete = ManagedCriticalState(false)
|
||||
let finished = expectation(description: "finished")
|
||||
|
||||
Task {
|
||||
channel.finish()
|
||||
complete.withCriticalRegion { $0 = true }
|
||||
finished.fulfill()
|
||||
}
|
||||
|
||||
let valueFromConsumer1 = ManagedCriticalState<String?>(nil)
|
||||
let valueFromConsumer2 = ManagedCriticalState<String?>(nil)
|
||||
|
||||
let received = expectation(description: "received")
|
||||
received.expectedFulfillmentCount = 2
|
||||
|
||||
let pastEnd = expectation(description: "pastEnd")
|
||||
pastEnd.expectedFulfillmentCount = 2
|
||||
|
||||
Task {
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
let ending = try await iterator.next()
|
||||
valueFromConsumer1.withCriticalRegion { $0 = ending }
|
||||
received.fulfill()
|
||||
let item = try await iterator.next()
|
||||
XCTAssertNil(item)
|
||||
pastEnd.fulfill()
|
||||
}
|
||||
|
||||
Task {
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
let ending = try await iterator.next()
|
||||
valueFromConsumer2.withCriticalRegion { $0 = ending }
|
||||
received.fulfill()
|
||||
let item = try await iterator.next()
|
||||
XCTAssertNil(item)
|
||||
pastEnd.fulfill()
|
||||
}
|
||||
|
||||
wait(for: [finished, received], timeout: 1.0)
|
||||
|
||||
XCTAssertTrue(complete.withCriticalRegion { $0 })
|
||||
XCTAssertEqual(valueFromConsumer1.withCriticalRegion { $0 }, nil)
|
||||
XCTAssertEqual(valueFromConsumer2.withCriticalRegion { $0 }, nil)
|
||||
|
||||
wait(for: [pastEnd], timeout: 1.0)
|
||||
let additionalSend = expectation(description: "additional send")
|
||||
Task {
|
||||
await channel.send("test")
|
||||
additionalSend.fulfill()
|
||||
}
|
||||
wait(for: [additionalSend], timeout: 1.0)
|
||||
}
|
||||
|
||||
func test_asyncChannel_ends_iterator_when_task_is_cancelled() async {
|
||||
let channel = AsyncChannel<String>()
|
||||
let ready = expectation(description: "ready")
|
||||
let task: Task<String?, Never> = Task {
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
ready.fulfill()
|
||||
// Given: 2 suspended iterations
|
||||
let task1 = Task<Int?, Never> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
return await iterator.next()
|
||||
}
|
||||
wait(for: [ready], timeout: 1.0)
|
||||
task.cancel()
|
||||
let value = await task.value
|
||||
XCTAssertNil(value)
|
||||
|
||||
let task2 = Task<Int?, Never> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
return await iterator.next()
|
||||
}
|
||||
|
||||
// When: finishing the channel
|
||||
sut.finish()
|
||||
|
||||
// Then: the iterations are resumed with nil values
|
||||
let (collected1, collected2) = await (task1.value, task2.value)
|
||||
XCTAssertNil(collected1)
|
||||
XCTAssertNil(collected2)
|
||||
|
||||
// When: requesting a next value
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
let pastEnd = await iterator.next()
|
||||
|
||||
// Then: the past end is nil
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_ends_iterator_when_task_is_cancelled() async throws {
|
||||
let channel = AsyncThrowingChannel<String, Error>()
|
||||
let ready = expectation(description: "ready")
|
||||
let task: Task<String?, Error> = Task {
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
ready.fulfill()
|
||||
return try await iterator.next()
|
||||
func test_asyncChannel_resumes_producer_when_task_is_cancelled() async {
|
||||
let send1IsResumed = expectation(description: "The first send operation is resumed")
|
||||
|
||||
// Given: an AsyncChannel
|
||||
let sut = AsyncChannel<Int>()
|
||||
|
||||
// Given: 2 suspended send operations
|
||||
let task1 = Task {
|
||||
await sut.send(1)
|
||||
send1IsResumed.fulfill()
|
||||
}
|
||||
wait(for: [ready], timeout: 1.0)
|
||||
task.cancel()
|
||||
let value = try await task.value
|
||||
XCTAssertNil(value)
|
||||
|
||||
let task2 = Task {
|
||||
await sut.send(2)
|
||||
}
|
||||
|
||||
// When: cancelling the first task
|
||||
task1.cancel()
|
||||
|
||||
// Then: the first sending operation is resumed
|
||||
wait(for: [send1IsResumed], timeout: 1.0)
|
||||
|
||||
// When: collecting elements
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
let collected = await iterator.next()
|
||||
|
||||
// Then: the second operation resumes and the iteration receives the element
|
||||
_ = await task2.value
|
||||
XCTAssertEqual(collected, 2)
|
||||
}
|
||||
|
||||
func test_asyncChannel_resumes_send_when_task_is_cancelled_and_continue_remaining_send_tasks() async {
|
||||
let channel = AsyncChannel<Int>()
|
||||
let notYetDone = expectation(description: "not yet done")
|
||||
notYetDone.isInverted = true
|
||||
let done = expectation(description: "done")
|
||||
let task = Task {
|
||||
await channel.send(1)
|
||||
notYetDone.fulfill()
|
||||
done.fulfill()
|
||||
|
||||
func test_asyncChannel_resumes_consumer_when_task_is_cancelled() async {
|
||||
// Given: an AsyncChannel
|
||||
let sut = AsyncChannel<Int>()
|
||||
|
||||
// Given: 2 suspended iterations
|
||||
let task1 = Task<Int?, Never> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
return await iterator.next()
|
||||
}
|
||||
|
||||
Task {
|
||||
await channel.send(2)
|
||||
let task2 = Task<Int?, Never> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
return await iterator.next()
|
||||
}
|
||||
|
||||
wait(for: [notYetDone], timeout: 0.1)
|
||||
task.cancel()
|
||||
wait(for: [done], timeout: 1.0)
|
||||
// When: cancelling the first task
|
||||
task1.cancel()
|
||||
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
let received = await iterator.next()
|
||||
XCTAssertEqual(received, 2)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_resumes_send_when_task_is_cancelled_and_continue_remaining_send_tasks() async throws {
|
||||
let channel = AsyncThrowingChannel<Int, Error>()
|
||||
let notYetDone = expectation(description: "not yet done")
|
||||
notYetDone.isInverted = true
|
||||
let done = expectation(description: "done")
|
||||
let task = Task {
|
||||
await channel.send(1)
|
||||
notYetDone.fulfill()
|
||||
done.fulfill()
|
||||
}
|
||||
// Then: the iteration is resumed with a nil element
|
||||
let collected1 = await task1.value
|
||||
XCTAssertNil(collected1)
|
||||
|
||||
Task {
|
||||
await channel.send(2)
|
||||
}
|
||||
// When: sending an element
|
||||
await sut.send(1)
|
||||
|
||||
wait(for: [notYetDone], timeout: 0.1)
|
||||
task.cancel()
|
||||
wait(for: [done], timeout: 1.0)
|
||||
|
||||
var iterator = channel.makeAsyncIterator()
|
||||
let received = try await iterator.next()
|
||||
XCTAssertEqual(received, 2)
|
||||
// Then: the second iteration is resumed with the element
|
||||
let collected2 = await task2.value
|
||||
XCTAssertEqual(collected2, 1)
|
||||
}
|
||||
}
|
||||
@@ -318,6 +318,16 @@ final class TestCombineLatest2: XCTestCase {
|
||||
task.cancel()
|
||||
wait(for: [finished], timeout: 1.0)
|
||||
}
|
||||
|
||||
func test_combineLatest_when_cancelled() async {
|
||||
let t = Task {
|
||||
try? await Task.sleep(nanoseconds: 1_000_000_000)
|
||||
let c1 = Indefinite(value: "test1").async
|
||||
let c2 = Indefinite(value: "test1").async
|
||||
for await _ in combineLatest(c1, c2) {}
|
||||
}
|
||||
t.cancel()
|
||||
}
|
||||
}
|
||||
|
||||
final class TestCombineLatest3: XCTestCase {
|
||||
|
||||
@@ -68,4 +68,15 @@ final class TestDebounce: XCTestCase {
|
||||
let throwingDebounce = [1].async.map { try throwOn(2, $0) }.debounce(for: .zero, clock: ContinuousClock())
|
||||
for try await _ in throwingDebounce {}
|
||||
}
|
||||
|
||||
func test_debounce_when_cancelled() async throws {
|
||||
guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { throw XCTSkip("Skipped due to Clock/Instant/Duration availability") }
|
||||
|
||||
let t = Task {
|
||||
try? await Task.sleep(nanoseconds: 1_000_000_000)
|
||||
let c1 = Indefinite(value: "test1").async
|
||||
for await _ in c1.debounce(for: .seconds(1), clock: .continuous) {}
|
||||
}
|
||||
t.cancel()
|
||||
}
|
||||
}
|
||||
@@ -13,8 +13,8 @@ import XCTest
|
||||
import AsyncAlgorithms
|
||||
|
||||
extension Sequence where Element: Sequence, Element.Element: Equatable & Sendable {
|
||||
func nestedAsync(throwsOn bad: Element.Element) -> AsyncLazySequence<[AsyncThrowingMapSequence<AsyncLazySequence<Element>,Element.Element>]> {
|
||||
let array: [AsyncThrowingMapSequence<AsyncLazySequence<Element>,Element.Element>] = self.map { $0.async }.map {
|
||||
func nestedAsync(throwsOn bad: Element.Element) -> AsyncSyncSequence<[AsyncThrowingMapSequence<AsyncSyncSequence<Element>,Element.Element>]> {
|
||||
let array: [AsyncThrowingMapSequence<AsyncSyncSequence<Element>,Element.Element>] = self.map { $0.async }.map {
|
||||
$0.map { try throwOn(bad, $0) }
|
||||
}
|
||||
return array.async
|
||||
@@ -22,7 +22,7 @@ extension Sequence where Element: Sequence, Element.Element: Equatable & Sendabl
|
||||
}
|
||||
|
||||
extension Sequence where Element: Sequence, Element.Element: Sendable {
|
||||
var nestedAsync : AsyncLazySequence<[AsyncLazySequence<Element>]> {
|
||||
var nestedAsync : AsyncSyncSequence<[AsyncSyncSequence<Element>]> {
|
||||
return self.map { $0.async }.async
|
||||
}
|
||||
}
|
||||
@@ -55,7 +55,7 @@ final class TestJoinedBySeparator: XCTestCase {
|
||||
}
|
||||
|
||||
func test_join_empty() async {
|
||||
let sequences = [AsyncLazySequence<[Int]>]().async
|
||||
let sequences = [AsyncSyncSequence<[Int]>]().async
|
||||
var iterator = sequences.joined(separator: [-1, -2, -3].async).makeAsyncIterator()
|
||||
let expected = [Int]()
|
||||
var actual = [Int]()
|
||||
@@ -105,7 +105,7 @@ final class TestJoinedBySeparator: XCTestCase {
|
||||
}
|
||||
|
||||
func test_cancellation() async {
|
||||
let source : AsyncLazySequence<[AsyncLazySequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
|
||||
let source : AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
|
||||
let sequence = source.joined(separator: ["past indefinite"].async)
|
||||
let finished = expectation(description: "finished")
|
||||
let iterated = expectation(description: "iterated")
|
||||
@@ -158,7 +158,7 @@ final class TestJoined: XCTestCase {
|
||||
}
|
||||
|
||||
func test_join_empty() async {
|
||||
let sequences = [AsyncLazySequence<[Int]>]().async
|
||||
let sequences = [AsyncSyncSequence<[Int]>]().async
|
||||
var iterator = sequences.joined().makeAsyncIterator()
|
||||
let expected = [Int]()
|
||||
var actual = [Int]()
|
||||
@@ -189,7 +189,7 @@ final class TestJoined: XCTestCase {
|
||||
}
|
||||
|
||||
func test_cancellation() async {
|
||||
let source : AsyncLazySequence<[AsyncLazySequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
|
||||
let source : AsyncSyncSequence<[AsyncSyncSequence<Indefinite<String>>]> = [Indefinite(value: "test").async].async
|
||||
let sequence = source.joined()
|
||||
let finished = expectation(description: "finished")
|
||||
let iterated = expectation(description: "iterated")
|
||||
|
||||
@@ -191,6 +191,16 @@ final class TestMerge2: XCTestCase {
|
||||
task.cancel()
|
||||
wait(for: [finished], timeout: 1.0)
|
||||
}
|
||||
|
||||
func test_merge_when_cancelled() async {
|
||||
let t = Task {
|
||||
try? await Task.sleep(nanoseconds: 1_000_000_000)
|
||||
let c1 = Indefinite(value: "test1").async
|
||||
let c2 = Indefinite(value: "test1").async
|
||||
for await _ in merge(c1, c2) {}
|
||||
}
|
||||
t.cancel()
|
||||
}
|
||||
}
|
||||
|
||||
final class TestMerge3: XCTestCase {
|
||||
|
||||
@@ -0,0 +1,313 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Async Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import AsyncAlgorithms
|
||||
|
||||
final class TestThrowingChannel: XCTestCase {
|
||||
func test_asyncThrowingChannel_delivers_elements_when_several_producers_and_several_consumers() async throws {
|
||||
let sents = (1...10)
|
||||
let expected = Set(sents)
|
||||
|
||||
// Given: an AsyncThrowingChannel
|
||||
let sut = AsyncThrowingChannel<Int, Error>()
|
||||
|
||||
// When: sending elements from tasks in a group
|
||||
Task {
|
||||
await withTaskGroup(of: Void.self) { group in
|
||||
for sent in sents {
|
||||
group.addTask {
|
||||
await sut.send(sent)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// When: receiving those elements from tasks in a group
|
||||
let collected = try await withThrowingTaskGroup(of: Int.self, returning: Set<Int>.self) { group in
|
||||
for _ in sents {
|
||||
group.addTask {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
let received = try await iterator.next()
|
||||
return received!
|
||||
}
|
||||
}
|
||||
|
||||
var collected = Set<Int>()
|
||||
for try await element in group {
|
||||
collected.update(with: element)
|
||||
}
|
||||
return collected
|
||||
}
|
||||
|
||||
// Then: all elements are sent and received
|
||||
XCTAssertEqual(collected, expected)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_resumes_producers_and_discards_additional_elements_when_finish_is_called() async throws {
|
||||
// Given: an AsyncThrowingChannel
|
||||
let sut = AsyncThrowingChannel<Int, Error>()
|
||||
|
||||
// Given: 2 suspended send operations
|
||||
let task1 = Task {
|
||||
await sut.send(1)
|
||||
}
|
||||
|
||||
let task2 = Task {
|
||||
await sut.send(2)
|
||||
}
|
||||
|
||||
// When: finishing the channel
|
||||
sut.finish()
|
||||
|
||||
// Then: the send operations are resumed
|
||||
_ = await (task1.value, task2.value)
|
||||
|
||||
// When: sending an extra value
|
||||
await sut.send(3)
|
||||
|
||||
// Then: the operation and the iteration are immediately resumed
|
||||
var collected = [Int]()
|
||||
for try await element in sut {
|
||||
collected.append(element)
|
||||
}
|
||||
XCTAssertTrue(collected.isEmpty)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_resumes_producers_and_discards_additional_elements_when_fail_is_called() async throws {
|
||||
// Given: an AsyncThrowingChannel
|
||||
let sut = AsyncThrowingChannel<Int, Error>()
|
||||
|
||||
// Given: 2 suspended send operations
|
||||
let task1 = Task {
|
||||
await sut.send(1)
|
||||
}
|
||||
|
||||
let task2 = Task {
|
||||
await sut.send(2)
|
||||
}
|
||||
|
||||
// When: failing the channel
|
||||
sut.fail(Failure())
|
||||
|
||||
// Then: the send operations are resumed
|
||||
_ = await (task1.value, task2.value)
|
||||
|
||||
// When: sending an extra value
|
||||
await sut.send(3)
|
||||
|
||||
// Then: the send operation is resumed
|
||||
// Then: the iteration is resumed with a failure
|
||||
var collected = [Int]()
|
||||
do {
|
||||
for try await element in sut {
|
||||
collected.append(element)
|
||||
}
|
||||
} catch {
|
||||
XCTAssertTrue(collected.isEmpty)
|
||||
XCTAssertEqual(error as? Failure, Failure())
|
||||
}
|
||||
|
||||
// When: requesting a next value
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
let pastFailure = try await iterator.next()
|
||||
|
||||
// Then: the past failure is nil
|
||||
XCTAssertNil(pastFailure)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_resumes_consumers_when_finish_is_called() async throws {
|
||||
// Given: an AsyncThrowingChannel
|
||||
let sut = AsyncThrowingChannel<Int, Error>()
|
||||
|
||||
// Given: 2 suspended iterations
|
||||
let task1 = Task<Int?, Error> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
return try await iterator.next()
|
||||
}
|
||||
|
||||
let task2 = Task<Int?, Error> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
return try await iterator.next()
|
||||
}
|
||||
|
||||
|
||||
// When: finishing the channel
|
||||
sut.finish()
|
||||
|
||||
// Then: the iterations are resumed with nil values
|
||||
let (collected1, collected2) = try await (task1.value, task2.value)
|
||||
XCTAssertNil(collected1)
|
||||
XCTAssertNil(collected2)
|
||||
|
||||
// When: requesting a next value
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
let pastEnd = try await iterator.next()
|
||||
|
||||
// Then: the past end is nil
|
||||
XCTAssertNil(pastEnd)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_resumes_consumer_when_fail_is_called() async throws {
|
||||
// Given: an AsyncThrowingChannel
|
||||
let sut = AsyncThrowingChannel<Int, Error>()
|
||||
|
||||
// Given: suspended iteration
|
||||
let task = Task<Int?, Error> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
|
||||
do {
|
||||
_ = try await iterator.next()
|
||||
XCTFail("We expect the above call to throw")
|
||||
} catch {
|
||||
XCTAssertEqual(error as? Failure, Failure())
|
||||
}
|
||||
|
||||
return try await iterator.next()
|
||||
}
|
||||
|
||||
// When: failing the channel
|
||||
sut.fail(Failure())
|
||||
|
||||
// Then: the iterations are resumed with the error and the next element is nil
|
||||
do {
|
||||
let collected = try await task.value
|
||||
XCTAssertNil(collected)
|
||||
} catch {
|
||||
XCTFail("The task should not fail, the past failure element should be nil, not a failure.")
|
||||
}
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_resumes_consumers_when_fail_is_called() async throws {
|
||||
// Given: an AsyncThrowingChannel
|
||||
let sut = AsyncThrowingChannel<Int, Error>()
|
||||
|
||||
// Given: 2 suspended iterations
|
||||
let task1 = Task<Int?, Error> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
return try await iterator.next()
|
||||
}
|
||||
|
||||
let task2 = Task<Int?, Error> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
return try await iterator.next()
|
||||
}
|
||||
|
||||
// When: failing the channel
|
||||
sut.fail(Failure())
|
||||
|
||||
// Then: the iterations are resumed with the error
|
||||
do {
|
||||
_ = try await task1.value
|
||||
} catch {
|
||||
XCTAssertEqual(error as? Failure, Failure())
|
||||
}
|
||||
|
||||
do {
|
||||
_ = try await task2.value
|
||||
} catch {
|
||||
XCTAssertEqual(error as? Failure, Failure())
|
||||
}
|
||||
|
||||
// When: requesting a next value
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
let pastFailure = try await iterator.next()
|
||||
|
||||
// Then: the past failure is nil
|
||||
XCTAssertNil(pastFailure)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_resumes_consumer_with_error_when_already_failed() async throws {
|
||||
// Given: an AsyncThrowingChannel that is failed
|
||||
let sut = AsyncThrowingChannel<Int, Error>()
|
||||
sut.fail(Failure())
|
||||
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
|
||||
// When: requesting the next element
|
||||
do {
|
||||
_ = try await iterator.next()
|
||||
} catch {
|
||||
// Then: the iteration is resumed with the error
|
||||
XCTAssertEqual(error as? Failure, Failure())
|
||||
}
|
||||
|
||||
// When: requesting the next element past failure
|
||||
do {
|
||||
let pastFailure = try await iterator.next()
|
||||
// Then: the past failure is nil
|
||||
XCTAssertNil(pastFailure)
|
||||
} catch {
|
||||
XCTFail("The past failure should not throw")
|
||||
}
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_resumes_producer_when_task_is_cancelled() async throws {
|
||||
let send1IsResumed = expectation(description: "The first send operation is resumed")
|
||||
|
||||
// Given: an AsyncThrowingChannel
|
||||
let sut = AsyncThrowingChannel<Int, Error>()
|
||||
|
||||
// Given: 2 suspended send operations
|
||||
let task1 = Task {
|
||||
await sut.send(1)
|
||||
send1IsResumed.fulfill()
|
||||
}
|
||||
|
||||
let task2 = Task {
|
||||
await sut.send(2)
|
||||
}
|
||||
|
||||
// When: cancelling the first task
|
||||
task1.cancel()
|
||||
|
||||
// Then: the first sending operation is resumed
|
||||
wait(for: [send1IsResumed], timeout: 1.0)
|
||||
|
||||
// When: collecting elements
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
let collected = try await iterator.next()
|
||||
|
||||
// Then: the second operation resumes and the iteration receives the element
|
||||
_ = await task2.value
|
||||
XCTAssertEqual(collected, 2)
|
||||
}
|
||||
|
||||
func test_asyncThrowingChannel_resumes_consumer_when_task_is_cancelled() async throws {
|
||||
// Given: an AsyncThrowingChannel
|
||||
let sut = AsyncThrowingChannel<Int, Error>()
|
||||
|
||||
// Given: 2 suspended iterations
|
||||
let task1 = Task<Int?, Error> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
return try await iterator.next()
|
||||
}
|
||||
|
||||
let task2 = Task<Int?, Error> {
|
||||
var iterator = sut.makeAsyncIterator()
|
||||
return try await iterator.next()
|
||||
}
|
||||
|
||||
// When: cancelling the first task
|
||||
task1.cancel()
|
||||
|
||||
// Then: the first iteration is resumed with a nil element
|
||||
let collected1 = try await task1.value
|
||||
XCTAssertNil(collected1)
|
||||
|
||||
// When: sending an element
|
||||
await sut.send(1)
|
||||
|
||||
// Then: the second iteration is resumed with the element
|
||||
let collected2 = try await task2.value
|
||||
XCTAssertEqual(collected2, 1)
|
||||
}
|
||||
}
|
||||
@@ -158,6 +158,16 @@ final class TestZip2: XCTestCase {
|
||||
task.cancel()
|
||||
wait(for: [finished], timeout: 1.0)
|
||||
}
|
||||
|
||||
func test_zip_when_cancelled() async {
|
||||
let t = Task {
|
||||
try? await Task.sleep(nanoseconds: 1_000_000_000)
|
||||
let c1 = Indefinite(value: "test1").async
|
||||
let c2 = Indefinite(value: "test1").async
|
||||
for await _ in zip(c1, c2) {}
|
||||
}
|
||||
t.cancel()
|
||||
}
|
||||
}
|
||||
|
||||
final class TestZip3: XCTestCase {
|
||||
|
||||
Reference in new issue
Block a user