unified-ble-manager 4.0.0-alpha.0

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

@@ -0,0 +1,135 @@
+//
+//  Zip.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 5/23/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+protocol ZipSinkProtocol: AnyObject {
+    func next(_ index: Int)
+    func fail(_ error: Swift.Error)
+    func done(_ index: Int)
+}
+
+class ZipSink<Observer: ObserverType> : Sink<Observer>, ZipSinkProtocol {
+    typealias Element = Observer.Element
+    
+    let arity: Int
+
+    let lock = RecursiveLock()
+
+    // state
+    private var isDone: [Bool]
+    
+    init(arity: Int, observer: Observer, cancel: Cancelable) {
+        self.isDone = [Bool](repeating: false, count: arity)
+        self.arity = arity
+        
+        super.init(observer: observer, cancel: cancel)
+    }
+
+    func getResult() throws -> Element {
+        rxAbstractMethod()
+    }
+    
+    func hasElements(_ index: Int) -> Bool {
+        rxAbstractMethod()
+    }
+    
+    func next(_ index: Int) {
+        var hasValueAll = true
+        
+        for i in 0 ..< self.arity {
+            if !self.hasElements(i) {
+                hasValueAll = false
+                break
+            }
+        }
+        
+        if hasValueAll {
+            do {
+                let result = try self.getResult()
+                self.forwardOn(.next(result))
+            }
+            catch let e {
+                self.forwardOn(.error(e))
+                self.dispose()
+            }
+        }
+    }
+    
+    func fail(_ error: Swift.Error) {
+        self.forwardOn(.error(error))
+        self.dispose()
+    }
+    
+    func done(_ index: Int) {
+        self.isDone[index] = true
+        
+        var allDone = true
+        
+        for done in self.isDone where !done {
+            allDone = false
+            break
+        }
+        
+        if allDone {
+            self.forwardOn(.completed)
+            self.dispose()
+        }
+    }
+}
+
+final class ZipObserver<Element>
+    : ObserverType
+    , LockOwnerType
+    , SynchronizedOnType {
+    typealias ValueSetter = (Element) -> Void
+
+    private var parent: ZipSinkProtocol?
+    
+    let lock: RecursiveLock
+    
+    // state
+    private let index: Int
+    private let this: Disposable
+    private let setNextValue: ValueSetter
+    
+    init(lock: RecursiveLock, parent: ZipSinkProtocol, index: Int, setNextValue: @escaping ValueSetter, this: Disposable) {
+        self.lock = lock
+        self.parent = parent
+        self.index = index
+        self.this = this
+        self.setNextValue = setNextValue
+    }
+    
+    func on(_ event: Event<Element>) {
+        self.synchronizedOn(event)
+    }
+
+    func synchronized_on(_ event: Event<Element>) {
+        if self.parent != nil {
+            switch event {
+            case .next:
+                break
+            case .error:
+                self.this.dispose()
+            case .completed:
+                self.this.dispose()
+            }
+        }
+        
+        if let parent = self.parent {
+            switch event {
+            case .next(let value):
+                self.setNextValue(value)
+                parent.next(self.index)
+            case .error(let error):
+                parent.fail(error)
+            case .completed:
+                parent.done(self.index)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+//
+//  ObserverType.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 2/8/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Supports push-style iteration over an observable sequence.
+public protocol ObserverType {
+    /// The type of elements in sequence that observer can observe.
+    associatedtype Element
+
+    /// Notify observer about sequence event.
+    ///
+    /// - parameter event: Event that occurred.
+    func on(_ event: Event<Element>)
+}
+
+/// Convenience API extensions to provide alternate next, error, completed events
+extension ObserverType {
+    
+    /// Convenience method equivalent to `on(.next(element: Element))`
+    ///
+    /// - parameter element: Next element to send to observer(s)
+    public func onNext(_ element: Element) {
+        self.on(.next(element))
+    }
+    
+    /// Convenience method equivalent to `on(.completed)`
+    public func onCompleted() {
+        self.on(.completed)
+    }
+    
+    /// Convenience method equivalent to `on(.error(Swift.Error))`
+    /// - parameter error: Swift.Error to send to observer(s)
+    public func onError(_ error: Swift.Error) {
+        self.on(.error(error))
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Observers/AnonymousObserver.swift

@@ -0,0 +1,30 @@
+//
+//  AnonymousObserver.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 2/8/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+final class AnonymousObserver<Element>: ObserverBase<Element> {
+    typealias EventHandler = (Event<Element>) -> Void
+    
+    private let eventHandler : EventHandler
+    
+    init(_ eventHandler: @escaping EventHandler) {
+#if TRACE_RESOURCES
+        _ = Resources.incrementTotal()
+#endif
+        self.eventHandler = eventHandler
+    }
+
+    override func onCore(_ event: Event<Element>) {
+        self.eventHandler(event)
+    }
+    
+#if TRACE_RESOURCES
+    deinit {
+        _ = Resources.decrementTotal()
+    }
+#endif
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Observers/ObserverBase.swift

@@ -0,0 +1,32 @@
+//
+//  ObserverBase.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 2/15/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+class ObserverBase<Element> : Disposable, ObserverType {
+    private let isStopped = AtomicInt(0)
+
+    func on(_ event: Event<Element>) {
+        switch event {
+        case .next:
+            if load(self.isStopped) == 0 {
+                self.onCore(event)
+            }
+        case .error, .completed:
+            if fetchOr(self.isStopped, 1) == 0 {
+                self.onCore(event)
+            }
+        }
+    }
+
+    func onCore(_ event: Event<Element>) {
+        rxAbstractMethod()
+    }
+
+    func dispose() {
+        fetchOr(self.isStopped, 1)
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Observers/TailRecursiveSink.swift

@@ -0,0 +1,151 @@
+//
+//  TailRecursiveSink.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 3/21/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+enum TailRecursiveSinkCommand {
+    case moveNext
+    case dispose
+}
+
+#if DEBUG || TRACE_RESOURCES
+    public var maxTailRecursiveSinkStackSize = 0
+#endif
+
+/// This class is usually used with `Generator` version of the operators.
+class TailRecursiveSink<Sequence: Swift.Sequence, Observer: ObserverType>
+    : Sink<Observer>
+    , InvocableWithValueType where Sequence.Element: ObservableConvertibleType, Sequence.Element.Element == Observer.Element {
+    typealias Value = TailRecursiveSinkCommand
+    typealias Element = Observer.Element 
+    typealias SequenceGenerator = (generator: Sequence.Iterator, remaining: IntMax?)
+
+    var generators: [SequenceGenerator] = []
+    var disposed = false
+    var subscription = SerialDisposable()
+
+    // this is thread safe object
+    var gate = AsyncLock<InvocableScheduledItem<TailRecursiveSink<Sequence, Observer>>>()
+
+    override init(observer: Observer, cancel: Cancelable) {
+        super.init(observer: observer, cancel: cancel)
+    }
+
+    func run(_ sources: SequenceGenerator) -> Disposable {
+        self.generators.append(sources)
+
+        self.schedule(.moveNext)
+
+        return self.subscription
+    }
+
+    func invoke(_ command: TailRecursiveSinkCommand) {
+        switch command {
+        case .dispose:
+            self.disposeCommand()
+        case .moveNext:
+            self.moveNextCommand()
+        }
+    }
+
+    // simple implementation for now
+    func schedule(_ command: TailRecursiveSinkCommand) {
+        self.gate.invoke(InvocableScheduledItem(invocable: self, state: command))
+    }
+
+    func done() {
+        self.forwardOn(.completed)
+        self.dispose()
+    }
+
+    func extract(_ observable: Observable<Element>) -> SequenceGenerator? {
+        rxAbstractMethod()
+    }
+
+    // should be done on gate locked
+
+    private func moveNextCommand() {
+        var next: Observable<Element>?
+
+        repeat {
+            guard let (g, left) = self.generators.last else {
+                break
+            }
+            
+            if self.isDisposed {
+                return
+            }
+
+            self.generators.removeLast()
+            
+            var e = g
+
+            guard let nextCandidate = e.next()?.asObservable() else {
+                continue
+            }
+
+            // `left` is a hint of how many elements are left in generator.
+            // In case this is the last element, then there is no need to push
+            // that generator on stack.
+            //
+            // This is an optimization used to make sure in tail recursive case
+            // there is no memory leak in case this operator is used to generate non terminating
+            // sequence.
+
+            if let knownOriginalLeft = left {
+                // `- 1` because generator.next() has just been called
+                if knownOriginalLeft - 1 >= 1 {
+                    self.generators.append((e, knownOriginalLeft - 1))
+                }
+            }
+            else {
+                self.generators.append((e, nil))
+            }
+
+            let nextGenerator = self.extract(nextCandidate)
+
+            if let nextGenerator = nextGenerator {
+                self.generators.append(nextGenerator)
+                #if DEBUG || TRACE_RESOURCES
+                    if maxTailRecursiveSinkStackSize < self.generators.count {
+                        maxTailRecursiveSinkStackSize = self.generators.count
+                    }
+                #endif
+            }
+            else {
+                next = nextCandidate
+            }
+        } while next == nil
+
+        guard let existingNext = next else {
+            self.done()
+            return
+        }
+
+        let disposable = SingleAssignmentDisposable()
+        self.subscription.disposable = disposable
+        disposable.setDisposable(self.subscribeToNext(existingNext))
+    }
+
+    func subscribeToNext(_ source: Observable<Element>) -> Disposable {
+        rxAbstractMethod()
+    }
+
+    func disposeCommand() {
+        self.disposed = true
+        self.generators.removeAll(keepingCapacity: false)
+    }
+
+    override func dispose() {
+        super.dispose()
+        
+        self.subscription.dispose()
+        self.gate.dispose()
+        
+        self.schedule(.dispose)
+    }
+}
+

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Platform/AtomicInt.swift

@@ -0,0 +1,72 @@
+//
+//  AtomicInt.swift
+//  Platform
+//
+//  Created by Krunoslav Zaher on 10/28/18.
+//  Copyright © 2018 Krunoslav Zaher. All rights reserved.
+//
+
+import Foundation
+
+final class AtomicInt: NSLock {
+    fileprivate var value: Int32
+    public init(_ value: Int32 = 0) {
+        self.value = value
+    }
+}
+
+@discardableResult
+@inline(__always)
+func add(_ this: AtomicInt, _ value: Int32) -> Int32 {
+    this.lock()
+    let oldValue = this.value
+    this.value += value
+    this.unlock()
+    return oldValue
+}
+
+@discardableResult
+@inline(__always)
+func sub(_ this: AtomicInt, _ value: Int32) -> Int32 {
+    this.lock()
+    let oldValue = this.value
+    this.value -= value
+    this.unlock()
+    return oldValue
+}
+
+@discardableResult
+@inline(__always)
+func fetchOr(_ this: AtomicInt, _ mask: Int32) -> Int32 {
+    this.lock()
+    let oldValue = this.value
+    this.value |= mask
+    this.unlock()
+    return oldValue
+}
+
+@inline(__always)
+func load(_ this: AtomicInt) -> Int32 {
+    this.lock()
+    let oldValue = this.value
+    this.unlock()
+    return oldValue
+}
+
+@discardableResult
+@inline(__always)
+func increment(_ this: AtomicInt) -> Int32 {
+    add(this, 1)
+}
+
+@discardableResult
+@inline(__always)
+func decrement(_ this: AtomicInt) -> Int32 {
+    sub(this, 1)
+}
+
+@inline(__always)
+func isFlagSet(_ this: AtomicInt, _ mask: Int32) -> Bool {
+    (load(this) & mask) != 0
+}
+

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Platform/DataStructures/Bag.swift

@@ -0,0 +1,181 @@
+//
+//  Bag.swift
+//  Platform
+//
+//  Created by Krunoslav Zaher on 2/28/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+import Swift
+
+let arrayDictionaryMaxSize = 30
+
+struct BagKey {
+    /**
+    Unique identifier for object added to `Bag`.
+     
+    It's underlying type is UInt64. If we assume there in an idealized CPU that works at 4GHz,
+     it would take ~150 years of continuous running time for it to overflow.
+    */
+    fileprivate let rawValue: UInt64
+}
+
+/**
+Data structure that represents a bag of elements typed `T`.
+
+Single element can be stored multiple times.
+
+Time and space complexity of insertion and deletion is O(n).
+
+It is suitable for storing small number of elements.
+*/
+struct Bag<T> : CustomDebugStringConvertible {
+    /// Type of identifier for inserted elements.
+    typealias KeyType = BagKey
+    
+    typealias Entry = (key: BagKey, value: T)
+ 
+    private var _nextKey: BagKey = BagKey(rawValue: 0)
+
+    // data
+
+    // first fill inline variables
+    var _key0: BagKey?
+    var _value0: T?
+
+    // then fill "array dictionary"
+    var _pairs = ContiguousArray<Entry>()
+
+    // last is sparse dictionary
+    var _dictionary: [BagKey: T]?
+
+    var _onlyFastPath = true
+
+    /// Creates new empty `Bag`.
+    init() {
+    }
+    
+    /**
+    Inserts `value` into bag.
+    
+    - parameter element: Element to insert.
+    - returns: Key that can be used to remove element from bag.
+    */
+    mutating func insert(_ element: T) -> BagKey {
+        let key = _nextKey
+
+        _nextKey = BagKey(rawValue: _nextKey.rawValue &+ 1)
+
+        if _key0 == nil {
+            _key0 = key
+            _value0 = element
+            return key
+        }
+
+        _onlyFastPath = false
+
+        if _dictionary != nil {
+            _dictionary![key] = element
+            return key
+        }
+
+        if _pairs.count < arrayDictionaryMaxSize {
+            _pairs.append((key: key, value: element))
+            return key
+        }
+        
+        _dictionary = [key: element]
+        
+        return key
+    }
+    
+    /// - returns: Number of elements in bag.
+    var count: Int {
+        let dictionaryCount: Int = _dictionary?.count ?? 0
+        return (_value0 != nil ? 1 : 0) + _pairs.count + dictionaryCount
+    }
+    
+    /// Removes all elements from bag and clears capacity.
+    mutating func removeAll() {
+        _key0 = nil
+        _value0 = nil
+
+        _pairs.removeAll(keepingCapacity: false)
+        _dictionary?.removeAll(keepingCapacity: false)
+    }
+    
+    /**
+    Removes element with a specific `key` from bag.
+    
+    - parameter key: Key that identifies element to remove from bag.
+    - returns: Element that bag contained, or nil in case element was already removed.
+    */
+    mutating func removeKey(_ key: BagKey) -> T? {
+        if _key0 == key {
+            _key0 = nil
+            let value = _value0!
+            _value0 = nil
+            return value
+        }
+
+        if let existingObject = _dictionary?.removeValue(forKey: key) {
+            return existingObject
+        }
+
+        for i in 0 ..< _pairs.count where _pairs[i].key == key {
+            let value = _pairs[i].value
+            _pairs.remove(at: i)
+            return value
+        }
+
+        return nil
+    }
+}
+
+extension Bag {
+    /// A textual representation of `self`, suitable for debugging.
+    var debugDescription : String {
+        "\(self.count) elements in Bag"
+    }
+}
+
+extension Bag {
+    /// Enumerates elements inside the bag.
+    ///
+    /// - parameter action: Enumeration closure.
+    func forEach(_ action: (T) -> Void) {
+        if _onlyFastPath {
+            if let value0 = _value0 {
+                action(value0)
+            }
+            return
+        }
+
+        let value0 = _value0
+        let dictionary = _dictionary
+
+        if let value0 = value0 {
+            action(value0)
+        }
+
+        for i in 0 ..< _pairs.count {
+            action(_pairs[i].value)
+        }
+
+        if dictionary?.count ?? 0 > 0 {
+            for element in dictionary!.values {
+                action(element)
+            }
+        }
+    }
+}
+
+extension BagKey: Hashable {
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(rawValue)
+    }
+}
+
+func ==(lhs: BagKey, rhs: BagKey) -> Bool {
+    lhs.rawValue == rhs.rawValue
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Platform/DataStructures/InfiniteSequence.swift

@@ -0,0 +1,23 @@
+//
+//  InfiniteSequence.swift
+//  Platform
+//
+//  Created by Krunoslav Zaher on 6/13/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Sequence that repeats `repeatedValue` infinite number of times.
+struct InfiniteSequence<Element> : Sequence {
+    typealias Iterator = AnyIterator<Element>
+    
+    private let repeatedValue: Element
+    
+    init(repeatedValue: Element) {
+        self.repeatedValue = repeatedValue
+    }
+    
+    func makeIterator() -> Iterator {
+        let repeatedValue = self.repeatedValue
+        return AnyIterator { repeatedValue }
+    }
+}