unified-ble-manager 4.0.0-alpha.0

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Observable.swift

@@ -0,0 +1,31 @@
+//
+//  Observable.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 2/8/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// A type-erased `ObservableType`. 
+///
+/// It represents a push style sequence.
+public class Observable<Element> : ObservableType {
+    init() {
+#if TRACE_RESOURCES
+        _ = Resources.incrementTotal()
+#endif
+    }
+    
+    public func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
+        rxAbstractMethod()
+    }
+    
+    public func asObservable() -> Observable<Element> { self }
+    
+    deinit {
+#if TRACE_RESOURCES
+        _ = Resources.decrementTotal()
+#endif
+    }
+}
+

package/ios/vendor/MultiplatformBleAdapter/RxSwift/ObservableConvertibleType.swift

@@ -0,0 +1,18 @@
+//
+//  ObservableConvertibleType.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 9/17/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Type that can be converted to observable sequence (`Observable<Element>`).
+public protocol ObservableConvertibleType {
+    /// Type of elements in sequence.
+    associatedtype Element
+
+    /// Converts `self` to `Observable` sequence.
+    ///
+    /// - returns: Observable sequence that represents `self`.
+    func asObservable() -> Observable<Element>
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/ObservableType+Extensions.swift

@@ -0,0 +1,174 @@
+//
+//  ObservableType+Extensions.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 2/21/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+#if DEBUG
+    import Foundation
+#endif
+
+extension ObservableType {
+    /**
+     Subscribes an event handler to an observable sequence.
+     
+     - parameter on: Action to invoke for each event in the observable sequence.
+     - returns: Subscription object used to unsubscribe from the observable sequence.
+     */
+    public func subscribe(_ on: @escaping (Event<Element>) -> Void) -> Disposable {
+        let observer = AnonymousObserver { e in
+            on(e)
+        }
+        return self.asObservable().subscribe(observer)
+    }
+    
+    /**
+     Subscribes an element handler, an error handler, a completion handler and disposed handler to an observable sequence.
+     
+     Also, take in an object and provide an unretained, safe to use (i.e. not implicitly unwrapped), reference to it along with the events emitted by the sequence.
+     
+     - Note: If `object` can't be retained, none of the other closures will be invoked.
+     
+     - parameter object: The object to provide an unretained reference on.
+     - parameter onNext: Action to invoke for each element in the observable sequence.
+     - parameter onError: Action to invoke upon errored termination of the observable sequence.
+     - parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
+     - parameter onDisposed: Action to invoke upon any type of termination of sequence (if the sequence has
+     gracefully completed, errored, or if the generation is canceled by disposing subscription).
+     - returns: Subscription object used to unsubscribe from the observable sequence.
+     */
+    public func subscribe<Object: AnyObject>(
+        with object: Object,
+        onNext: ((Object, Element) -> Void)? = nil,
+        onError: ((Object, Swift.Error) -> Void)? = nil,
+        onCompleted: ((Object) -> Void)? = nil,
+        onDisposed: ((Object) -> Void)? = nil
+    ) -> Disposable {
+        subscribe(
+            onNext: { [weak object] in
+                guard let object = object else { return }
+                onNext?(object, $0)
+            },
+            onError: { [weak object] in
+                guard let object = object else { return }
+                onError?(object, $0)
+            },
+            onCompleted: { [weak object] in
+                guard let object = object else { return }
+                onCompleted?(object)
+            },
+            onDisposed: { [weak object] in
+                guard let object = object else { return }
+                onDisposed?(object)
+            }
+        )
+    }
+    
+    /**
+     Subscribes an element handler, an error handler, a completion handler and disposed handler to an observable sequence.
+     
+     - parameter onNext: Action to invoke for each element in the observable sequence.
+     - parameter onError: Action to invoke upon errored termination of the observable sequence.
+     - parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
+     - parameter onDisposed: Action to invoke upon any type of termination of sequence (if the sequence has
+     gracefully completed, errored, or if the generation is canceled by disposing subscription).
+     - returns: Subscription object used to unsubscribe from the observable sequence.
+     */
+    public func subscribe(
+        onNext: ((Element) -> Void)? = nil,
+        onError: ((Swift.Error) -> Void)? = nil,
+        onCompleted: (() -> Void)? = nil,
+        onDisposed: (() -> Void)? = nil
+    ) -> Disposable {
+            let disposable: Disposable
+            
+            if let disposed = onDisposed {
+                disposable = Disposables.create(with: disposed)
+            }
+            else {
+                disposable = Disposables.create()
+            }
+            
+            #if DEBUG
+                let synchronizationTracker = SynchronizationTracker()
+            #endif
+            
+            let callStack = Hooks.recordCallStackOnError ? Hooks.customCaptureSubscriptionCallstack() : []
+            
+            let observer = AnonymousObserver<Element> { event in
+                
+                #if DEBUG
+                    synchronizationTracker.register(synchronizationErrorMessage: .default)
+                    defer { synchronizationTracker.unregister() }
+                #endif
+                
+                switch event {
+                case .next(let value):
+                    onNext?(value)
+                case .error(let error):
+                    if let onError = onError {
+                        onError(error)
+                    }
+                    else {
+                        Hooks.defaultErrorHandler(callStack, error)
+                    }
+                    disposable.dispose()
+                case .completed:
+                    onCompleted?()
+                    disposable.dispose()
+                }
+            }
+            return Disposables.create(
+                self.asObservable().subscribe(observer),
+                disposable
+            )
+    }
+}
+
+import Foundation
+
+extension Hooks {
+    public typealias DefaultErrorHandler = (_ subscriptionCallStack: [String], _ error: Error) -> Void
+    public typealias CustomCaptureSubscriptionCallstack = () -> [String]
+
+    private static let lock = RecursiveLock()
+    private static var _defaultErrorHandler: DefaultErrorHandler = { subscriptionCallStack, error in
+        #if DEBUG
+            let serializedCallStack = subscriptionCallStack.joined(separator: "\n")
+            print("Unhandled error happened: \(error)")
+            if !serializedCallStack.isEmpty {
+                print("subscription called from:\n\(serializedCallStack)")
+            }
+        #endif
+    }
+    private static var _customCaptureSubscriptionCallstack: CustomCaptureSubscriptionCallstack = {
+        #if DEBUG
+            return Thread.callStackSymbols
+        #else
+            return []
+        #endif
+    }
+
+    /// Error handler called in case onError handler wasn't provided.
+    public static var defaultErrorHandler: DefaultErrorHandler {
+        get {
+            lock.performLocked { _defaultErrorHandler }
+        }
+        set {
+            lock.performLocked { _defaultErrorHandler = newValue }
+        }
+    }
+    
+    /// Subscription callstack block to fetch custom callstack information.
+    public static var customCaptureSubscriptionCallstack: CustomCaptureSubscriptionCallstack {
+        get {
+            lock.performLocked { _customCaptureSubscriptionCallstack }
+        }
+        set {
+            lock.performLocked { _customCaptureSubscriptionCallstack = newValue }
+        }
+    }
+}
+

package/ios/vendor/MultiplatformBleAdapter/RxSwift/ObservableType.swift

@@ -0,0 +1,45 @@
+//
+//  ObservableType.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 8/8/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Represents a push style sequence.
+public protocol ObservableType: ObservableConvertibleType {
+    /**
+    Subscribes `observer` to receive events for this sequence.
+    
+    ### Grammar
+    
+    **Next\* (Error | Completed)?**
+    
+    * sequences can produce zero or more elements so zero or more `Next` events can be sent to `observer`
+    * once an `Error` or `Completed` event is sent, the sequence terminates and can't produce any other elements
+    
+    It is possible that events are sent from different threads, but no two events can be sent concurrently to
+    `observer`.
+    
+    ### Resource Management
+    
+    When sequence sends `Complete` or `Error` event all internal resources that compute sequence elements
+    will be freed.
+    
+    To cancel production of sequence elements and free resources immediately, call `dispose` on returned
+    subscription.
+    
+    - returns: Subscription for `observer` that can be used to cancel production of sequence elements and free resources.
+    */
+    func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element
+}
+
+extension ObservableType {
+    
+    /// Default implementation of converting `ObservableType` to `Observable`.
+    public func asObservable() -> Observable<Element> {
+        // temporary workaround
+        //return Observable.create(subscribe: self.subscribe)
+        Observable.create { o in self.subscribe(o) }
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Observables/AddRef.swift

@@ -0,0 +1,44 @@
+//
+//  AddRef.swift
+//  RxSwift
+//
+//  Created by Junior B. on 30/10/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+final class AddRefSink<Observer: ObserverType> : Sink<Observer>, ObserverType {
+    typealias Element = Observer.Element 
+    
+    override init(observer: Observer, cancel: Cancelable) {
+        super.init(observer: observer, cancel: cancel)
+    }
+    
+    func on(_ event: Event<Element>) {
+        switch event {
+        case .next:
+            self.forwardOn(event)
+        case .completed, .error:
+            self.forwardOn(event)
+            self.dispose()
+        }
+    }
+}
+
+final class AddRef<Element> : Producer<Element> {
+    
+    private let source: Observable<Element>
+    private let refCount: RefCountDisposable
+    
+    init(source: Observable<Element>, refCount: RefCountDisposable) {
+        self.source = source
+        self.refCount = refCount
+    }
+    
+    override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
+        let releaseDisposable = self.refCount.retain()
+        let sink = AddRefSink(observer: observer, cancel: cancel)
+        let subscription = Disposables.create(releaseDisposable, self.source.subscribe(sink))
+
+        return (sink: sink, subscription: subscription)
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Observables/Amb.swift

@@ -0,0 +1,157 @@
+//
+//  Amb.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 6/14/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+extension ObservableType {
+    /**
+     Propagates the observable sequence that reacts first.
+
+     - seealso: [amb operator on reactivex.io](http://reactivex.io/documentation/operators/amb.html)
+
+     - returns: An observable sequence that surfaces any of the given sequences, whichever reacted first.
+     */
+    public static func amb<Sequence: Swift.Sequence>(_ sequence: Sequence) -> Observable<Element>
+        where Sequence.Element == Observable<Element> {
+        sequence.reduce(Observable<Sequence.Element.Element>.never()) { a, o in
+            a.amb(o.asObservable())
+        }
+    }
+}
+
+extension ObservableType {
+
+    /**
+     Propagates the observable sequence that reacts first.
+
+     - seealso: [amb operator on reactivex.io](http://reactivex.io/documentation/operators/amb.html)
+
+     - parameter right: Second observable sequence.
+     - returns: An observable sequence that surfaces either of the given sequences, whichever reacted first.
+     */
+    public func amb<O2: ObservableType>
+        (_ right: O2)
+        -> Observable<Element> where O2.Element == Element {
+        Amb(left: self.asObservable(), right: right.asObservable())
+    }
+}
+
+private enum AmbState {
+    case neither
+    case left
+    case right
+}
+
+final private class AmbObserver<Observer: ObserverType>: ObserverType {
+    typealias Element = Observer.Element 
+    typealias Parent = AmbSink<Observer>
+    typealias This = AmbObserver<Observer>
+    typealias Sink = (This, Event<Element>) -> Void
+    
+    private let parent: Parent
+    fileprivate var sink: Sink
+    fileprivate var cancel: Disposable
+    
+    init(parent: Parent, cancel: Disposable, sink: @escaping Sink) {
+#if TRACE_RESOURCES
+        _ = Resources.incrementTotal()
+#endif
+        
+        self.parent = parent
+        self.sink = sink
+        self.cancel = cancel
+    }
+    
+    func on(_ event: Event<Element>) {
+        self.sink(self, event)
+        if event.isStopEvent {
+            self.cancel.dispose()
+        }
+    }
+    
+    deinit {
+#if TRACE_RESOURCES
+        _ = Resources.decrementTotal()
+#endif
+    }
+}
+
+final private class AmbSink<Observer: ObserverType>: Sink<Observer> {
+    typealias Element = Observer.Element
+    typealias Parent = Amb<Element>
+    typealias AmbObserverType = AmbObserver<Observer>
+
+    private let parent: Parent
+    
+    private let lock = RecursiveLock()
+    // state
+    private var choice = AmbState.neither
+    
+    init(parent: Parent, observer: Observer, cancel: Cancelable) {
+        self.parent = parent
+        super.init(observer: observer, cancel: cancel)
+    }
+    
+    func run() -> Disposable {
+        let subscription1 = SingleAssignmentDisposable()
+        let subscription2 = SingleAssignmentDisposable()
+        let disposeAll = Disposables.create(subscription1, subscription2)
+        
+        let forwardEvent = { (o: AmbObserverType, event: Event<Element>) -> Void in
+            self.forwardOn(event)
+            if event.isStopEvent {
+                self.dispose()
+            }
+        }
+
+        let decide = { (o: AmbObserverType, event: Event<Element>, me: AmbState, otherSubscription: Disposable) in
+            self.lock.performLocked {
+                if self.choice == .neither {
+                    self.choice = me
+                    o.sink = forwardEvent
+                    o.cancel = disposeAll
+                    otherSubscription.dispose()
+                }
+                
+                if self.choice == me {
+                    self.forwardOn(event)
+                    if event.isStopEvent {
+                        self.dispose()
+                    }
+                }
+            }
+        }
+        
+        let sink1 = AmbObserver(parent: self, cancel: subscription1) { o, e in
+            decide(o, e, .left, subscription2)
+        }
+        
+        let sink2 = AmbObserver(parent: self, cancel: subscription1) { o, e in
+            decide(o, e, .right, subscription1)
+        }
+        
+        subscription1.setDisposable(self.parent.left.subscribe(sink1))
+        subscription2.setDisposable(self.parent.right.subscribe(sink2))
+        
+        return disposeAll
+    }
+}
+
+final private class Amb<Element>: Producer<Element> {
+    fileprivate let left: Observable<Element>
+    fileprivate let right: Observable<Element>
+    
+    init(left: Observable<Element>, right: Observable<Element>) {
+        self.left = left
+        self.right = right
+    }
+    
+    override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
+        let sink = AmbSink(parent: self, observer: observer, cancel: cancel)
+        let subscription = sink.run()
+        return (sink: sink, subscription: subscription)
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Observables/AsMaybe.swift

@@ -0,0 +1,48 @@
+//
+//  AsMaybe.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 3/12/17.
+//  Copyright © 2017 Krunoslav Zaher. All rights reserved.
+//
+
+private final class AsMaybeSink<Observer: ObserverType> : Sink<Observer>, ObserverType {
+    typealias Element = Observer.Element
+
+    private var element: Event<Element>?
+
+    func on(_ event: Event<Element>) {
+        switch event {
+        case .next:
+            if self.element != nil {
+                self.forwardOn(.error(RxError.moreThanOneElement))
+                self.dispose()
+            }
+
+            self.element = event
+        case .error:
+            self.forwardOn(event)
+            self.dispose()
+        case .completed:
+            if let element = self.element {
+                self.forwardOn(element)
+            }
+            self.forwardOn(.completed)
+            self.dispose()
+        }
+    }
+}
+
+final class AsMaybe<Element>: Producer<Element> {
+    private let source: Observable<Element>
+
+    init(source: Observable<Element>) {
+        self.source = source
+    }
+
+    override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
+        let sink = AsMaybeSink(observer: observer, cancel: cancel)
+        let subscription = self.source.subscribe(sink)
+        return (sink: sink, subscription: subscription)
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Observables/AsSingle.swift

@@ -0,0 +1,51 @@
+//
+//  AsSingle.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 3/12/17.
+//  Copyright © 2017 Krunoslav Zaher. All rights reserved.
+//
+
+private final class AsSingleSink<Observer: ObserverType> : Sink<Observer>, ObserverType {
+    typealias Element = Observer.Element
+
+    private var element: Event<Element>?
+
+    func on(_ event: Event<Element>) {
+        switch event {
+        case .next:
+            if self.element != nil {
+                self.forwardOn(.error(RxError.moreThanOneElement))
+                self.dispose()
+            }
+
+            self.element = event
+        case .error:
+            self.forwardOn(event)
+            self.dispose()
+        case .completed:
+            if let element = self.element {
+                self.forwardOn(element)
+                self.forwardOn(.completed)
+            }
+            else {
+                self.forwardOn(.error(RxError.noElements))
+            }
+            self.dispose()
+        }
+    }
+}
+
+final class AsSingle<Element>: Producer<Element> {
+    private let source: Observable<Element>
+
+    init(source: Observable<Element>) {
+        self.source = source
+    }
+
+    override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
+        let sink = AsSingleSink(observer: observer, cancel: cancel)
+        let subscription = self.source.subscribe(sink)
+        return (sink: sink, subscription: subscription)
+    }
+}