@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/Combine/Publishers/Publishers.MeasureInterval.swift

@@ -0,0 +1,187 @@
+//
+//  Publishers.MeasureInterval.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+extension Publisher {
+
+    /// Measures and emits the time interval between events received from an upstream
+    /// publisher.
+    ///
+    /// Use `measureInterval(using:options:)` to measure the time between events delivered
+    /// from an upstream publisher.
+    ///
+    /// In the example below, a 1-second `Timer` is used as the data source for an event
+    /// publisher; the `measureInterval(using:options:)` operator reports the elapsed time
+    /// between the reception of events on the main run loop:
+    ///
+    ///     cancellable = Timer.publish(every: 1, on: .main, in: .default)
+    ///         .autoconnect()
+    ///         .measureInterval(using: RunLoop.main)
+    ///         .sink { print("\($0)", terminator: "\n") }
+    ///
+    ///     // Prints:
+    ///     //      Stride(magnitude: 1.0013610124588013)
+    ///     //      Stride(magnitude: 0.9992760419845581)
+    ///
+    /// The output type of the returned publisher is the time interval of the provided
+    /// scheduler.
+    ///
+    /// This operator uses the provided scheduler’s `now` property to measure intervals
+    /// between events.
+    ///
+    /// - Parameters:
+    ///   - scheduler: A scheduler to use for tracking the timing of events.
+    ///   - options: Options that customize the delivery of elements.
+    /// - Returns: A publisher that emits elements representing the time interval between
+    ///   the elements it receives.
+    public func measureInterval<Context: Scheduler>(
+        using scheduler: Context,
+        options: Context.SchedulerOptions? = nil
+    ) -> Publishers.MeasureInterval<Self, Context> {
+        return .init(upstream: self, scheduler: scheduler)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that measures and emits the time interval between events received from
+    /// an upstream publisher.
+    public struct MeasureInterval<Upstream: Publisher, Context: Scheduler>: Publisher {
+
+        public typealias Output = Context.SchedulerTimeType.Stride
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The scheduler used for tracking the timing of events.
+        public let scheduler: Context
+
+        /// Creates a publisher that measures and emits the time interval between events
+        /// received from an upstream publisher.
+        ///
+        /// - Parameters:
+        ///   - upstream: The publisher from which this publisher receives elements.
+        ///   - scheduler: A scheduler to use for tracking the timing of events.
+        public init(upstream: Upstream, scheduler: Context) {
+            self.upstream = upstream
+            self.scheduler = scheduler
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Downstream.Input == Context.SchedulerTimeType.Stride
+        {
+            upstream.subscribe(Inner(scheduler: scheduler, downstream: subscriber))
+        }
+    }
+}
+
+extension Publishers.MeasureInterval {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Context.SchedulerTimeType.Stride,
+              Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+        typealias Failure = Upstream.Failure
+
+        private let lock = UnfairLock.allocate()
+
+        private let downstream: Downstream
+
+        private let scheduler: Context
+
+        private var state = SubscriptionStatus.awaitingSubscription
+
+        private var last: Context.SchedulerTimeType?
+
+        init(scheduler: Context, downstream: Downstream) {
+            self.downstream = downstream
+            self.scheduler = scheduler
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case .awaitingSubscription = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(subscription)
+            last = scheduler.now
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receive(_: Input) -> Subscribers.Demand {
+            lock.lock()
+            guard case let .subscribed(subscription) = state,
+                  let previousTime = last else
+            {
+                lock.unlock()
+                return .none
+            }
+            let now = scheduler.now
+            last = now
+            lock.unlock()
+            let newDemand = downstream.receive(previousTime.distance(to: now))
+            if newDemand > 0 {
+                subscription.request(newDemand)
+            }
+            return .none
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            guard case .subscribed = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            last = nil
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(subscription) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(subscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            last = nil
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "MeasureInterval" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+    }
+}

package/Sources/Combine/Publishers/Publishers.Multicast.swift

@@ -0,0 +1,284 @@
+//
+//  Publishers.Multicast.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 14.06.2019.
+//
+
+extension Publisher {
+
+    /// Applies a closure to create a subject that delivers elements to subscribers.
+    ///
+    /// Use a multicast publisher when you have multiple downstream subscribers, but you
+    /// want upstream publishers to only process one `receive(_:)` call per event.
+    /// This is useful when upstream publishers are doing expensive work you don’t want
+    /// to duplicate, like performing network requests.
+    ///
+    /// In contrast with `multicast(subject:)`, this method produces a publisher that
+    /// creates a separate `Subject` for each subscriber.
+    ///
+    /// The following example uses a sequence publisher as a counter to publish three
+    /// random numbers, generated by a `map(_:)` operator.
+    /// It uses a `multicast(_:)` operator whose closure creates a `PassthroughSubject`
+    /// to share the same random number to each of two subscribers. Because the multicast
+    /// publisher is a `ConnectablePublisher`, publishing only begins after a call to
+    /// `connect()`.
+    ///
+    ///     let pub = ["First", "Second", "Third"].publisher
+    ///         .map( { return ($0, Int.random(in: 0...100)) } )
+    ///         .print("Random")
+    ///         .multicast { PassthroughSubject<(String, Int), Never>() }
+    ///
+    ///     cancellable1 = pub
+    ///        .sink { print ("Stream 1 received: \($0)")}
+    ///     cancellable2 = pub
+    ///        .sink { print ("Stream 2 received: \($0)")}
+    ///     pub.connect()
+    ///
+    ///     // Prints:
+    ///     // Random: receive value: (("First", 9))
+    ///     // Stream 2 received: ("First", 9)
+    ///     // Stream 1 received: ("First", 9)
+    ///     // Random: receive value: (("Second", 46))
+    ///     // Stream 2 received: ("Second", 46)
+    ///     // Stream 1 received: ("Second", 46)
+    ///     // Random: receive value: (("Third", 26))
+    ///     // Stream 2 received: ("Third", 26)
+    ///     // Stream 1 received: ("Third", 26)
+    ///
+    /// In this example, the output shows that the `print(_:to:)` operator receives each
+    /// random value only one time, and then sends the value to both subscribers.
+    ///
+    /// - Parameter createSubject: A closure to create a new `Subject` each time
+    ///   a subscriber attaches to the multicast publisher.
+    public func multicast<SubjectType: Subject>(
+        _ createSubject: @escaping () -> SubjectType
+    ) -> Publishers.Multicast<Self, SubjectType>
+        where Failure == SubjectType.Failure, Output == SubjectType.Output
+    {
+        return Publishers.Multicast(upstream: self, createSubject: createSubject)
+    }
+
+    /// Provides a subject to deliver elements to multiple subscribers.
+    ///
+    /// Use a multicast publisher when you have multiple downstream subscribers, but you
+    /// want upstream publishers to only process one `receive(_:)` call per event.
+    /// This is useful when upstream publishers are doing expensive work you don’t want
+    /// to duplicate, like performing network requests.
+    ///
+    /// In contrast with `multicast(_:)`, this method produces a publisher that shares
+    /// the provided `Subject` among all the downstream subscribers.
+    ///
+    /// The following example uses a sequence publisher as a counter to publish three
+    /// random numbers, generated by a `map(_:)` operator.
+    /// It uses a `multicast(subject:)` operator with a `PassthroughSubject` to share
+    /// the same random number to each of two subscribers. Because the multicast publisher
+    /// is a `ConnectablePublisher`, publishing only begins after a call to `connect()`.
+    ///
+    ///     let pub = ["First", "Second", "Third"].publisher
+    ///         .map( { return ($0, Int.random(in: 0...100)) } )
+    ///         .print("Random")
+    ///         .multicast(subject: PassthroughSubject<(String, Int), Never>())
+    ///
+    ///     cancellable1 = pub
+    ///         .sink { print ("Stream 1 received: \($0)")}
+    ///     cancellable2 = pub
+    ///         .sink { print ("Stream 2 received: \($0)")}
+    ///     pub.connect()
+    ///
+    ///     // Prints:
+    ///     // Random: receive value: (("First", 78))
+    ///     // Stream 2 received: ("First", 78)
+    ///     // Stream 1 received: ("First", 78)
+    ///     // Random: receive value: (("Second", 98))
+    ///     // Stream 2 received: ("Second", 98)
+    ///     // Stream 1 received: ("Second", 98)
+    ///     // Random: receive value: (("Third", 61))
+    ///     // Stream 2 received: ("Third", 61)
+    ///     // Stream 1 received: ("Third", 61)
+    ///
+    /// In this example, the output shows that the `print(_:to:)` operator receives each
+    /// random value only one time, and then sends the value to both subscribers.
+    ///
+    /// - Parameter subject: A subject to deliver elements to downstream subscribers.
+    public func multicast<SubjectType: Subject>(
+        subject: SubjectType
+    ) -> Publishers.Multicast<Self, SubjectType>
+        where Failure == SubjectType.Failure, Output == SubjectType.Output
+    {
+        return multicast { subject }
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that uses a subject to deliver elements to multiple subscribers.
+    ///
+    /// Use a multicast publisher when you have multiple downstream subscribers, but you
+    /// want upstream publishers to only process one `receive(_:)` call per event.
+    public final class Multicast<Upstream: Publisher, SubjectType: Subject>
+        : ConnectablePublisher
+        where Upstream.Failure == SubjectType.Failure,
+              Upstream.Output == SubjectType.Output
+    {
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher that this publisher receives elements from.
+        public let upstream: Upstream
+
+        /// A closure to create a new Subject each time a subscriber attaches
+        /// to the multicast publisher.
+        public let createSubject: () -> SubjectType
+
+        private let lock = UnfairLock.allocate()
+
+        private var subject: SubjectType?
+
+        private var lazySubject: SubjectType {
+            lock.lock()
+            if let subject = subject {
+                lock.unlock()
+                return subject
+            }
+
+            let subject = createSubject()
+            self.subject = subject
+            lock.unlock()
+            return subject
+        }
+
+        /// Creates a multicast publisher that applies a closure to create a subject that
+        /// delivers elements to subscribers.
+        ///
+        /// - Parameter createSubject: A closure that returns a `Subject` each time
+        ///   a subscriber attaches to the multicast publisher.
+        public init(upstream: Upstream, createSubject: @escaping () -> SubjectType) {
+            self.upstream = upstream
+            self.createSubject = createSubject
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where SubjectType.Failure == Downstream.Failure,
+                  SubjectType.Output == Downstream.Input
+        {
+            lazySubject.subscribe(Inner(parent: self, downstream: subscriber))
+        }
+
+        public func connect() -> Cancellable {
+            return upstream.subscribe(lazySubject)
+        }
+    }
+}
+
+extension Publishers.Multicast {
+
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Upstream.Output == Downstream.Input, Upstream.Failure == Downstream.Failure
+    {
+        // NOTE: This class has been audited for thread safety
+
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private enum State {
+            case ready(upstream: Upstream, downstream: Downstream)
+            case subscribed(upstream: Upstream,
+                            downstream: Downstream,
+                            subjectSubscription: Subscription)
+            case terminal
+        }
+
+        private let lock = UnfairLock.allocate()
+
+        private var state: State
+
+        fileprivate init(parent: Publishers.Multicast<Upstream, SubjectType>,
+                         downstream: Downstream) {
+            state = .ready(upstream: parent.upstream, downstream: downstream)
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        fileprivate var description: String { return "Multicast" }
+
+        fileprivate var customMirror: Mirror {
+            return Mirror(self, children: EmptyCollection())
+        }
+
+        fileprivate var playgroundDescription: Any { return description }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case let .ready(upstream, downstream) = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(upstream: upstream,
+                                downstream: downstream,
+                                subjectSubscription: subscription)
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            guard case let .subscribed(_, downstream, subjectSubscription) = state else {
+                lock.unlock()
+                return .none
+            }
+            lock.unlock()
+            let newDemand = downstream.receive(input)
+            if newDemand > 0 {
+                subjectSubscription.request(newDemand)
+            }
+            return .none
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            guard case let .subscribed(_, downstream, _) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(_, _, subjectSubscription) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subjectSubscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(_, _, subjectSubscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            subjectSubscription.cancel()
+        }
+    }
+}