unified-ble-manager 4.0.0-alpha.0

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

@@ -0,0 +1,19 @@
+//
+//  ConnectableObservableType.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 3/1/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/**
+Represents an observable sequence wrapper that can be connected and disconnected from its underlying observable sequence.
+*/
+public protocol ConnectableObservableType : ObservableType {
+    /**
+    Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established.
+    
+    - returns: Disposable used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence.
+    */
+    func connect() -> Disposable
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Date+Dispatch.swift

@@ -0,0 +1,64 @@
+//
+//  Date+Dispatch.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 4/14/19.
+//  Copyright © 2019 Krunoslav Zaher. All rights reserved.
+//
+
+import Dispatch
+import Foundation
+
+extension DispatchTimeInterval {
+    var convertToSecondsFactor: Double {
+        switch self {
+        case .nanoseconds: return 1_000_000_000.0
+        case .microseconds: return 1_000_000.0
+        case .milliseconds: return 1_000.0
+        case .seconds: return 1.0
+        case .never: fatalError()
+        @unknown default: fatalError()
+        }
+    }
+ 
+    func map(_ transform: (Int, Double) -> Int) -> DispatchTimeInterval {
+        switch self {
+        case .nanoseconds(let value): return .nanoseconds(transform(value, 1_000_000_000.0))
+        case .microseconds(let value): return .microseconds(transform(value, 1_000_000.0))
+        case .milliseconds(let value): return .milliseconds(transform(value, 1_000.0))
+        case .seconds(let value): return .seconds(transform(value, 1.0))
+        case .never: return .never
+        @unknown default: fatalError()
+        }
+    }
+    
+    var isNow: Bool {
+        switch self {
+        case .nanoseconds(let value), .microseconds(let value), .milliseconds(let value), .seconds(let value): return value == 0
+        case .never: return false
+        @unknown default: fatalError()
+        }
+    }
+    
+    internal func reduceWithSpanBetween(earlierDate: Date, laterDate: Date) -> DispatchTimeInterval {
+        return self.map { value, factor in
+            let interval = laterDate.timeIntervalSince(earlierDate)
+            let remainder = Double(value) - interval * factor
+            guard remainder > 0 else { return 0 }
+            return Int(remainder.rounded(.toNearestOrAwayFromZero))
+        }
+    }
+}
+
+extension Date {
+
+    internal func addingDispatchInterval(_ dispatchInterval: DispatchTimeInterval) -> Date {
+        switch dispatchInterval {
+        case .nanoseconds(let value), .microseconds(let value), .milliseconds(let value), .seconds(let value):
+            return self.addingTimeInterval(TimeInterval(value) / dispatchInterval.convertToSecondsFactor)
+        case .never: return Date.distantFuture
+        @unknown default: fatalError()
+        }
+    }
+    
+}

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

@@ -0,0 +1,13 @@
+//
+//  Disposable.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 2/8/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Represents a disposable resource.
+public protocol Disposable {
+    /// Dispose resource.
+    func dispose()
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Disposables/AnonymousDisposable.swift

@@ -0,0 +1,59 @@
+//
+//  AnonymousDisposable.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 2/15/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Represents an Action-based disposable.
+///
+/// When dispose method is called, disposal action will be dereferenced.
+private final class AnonymousDisposable : DisposeBase, Cancelable {
+    public typealias DisposeAction = () -> Void
+
+    private let disposed = AtomicInt(0)
+    private var disposeAction: DisposeAction?
+
+    /// - returns: Was resource disposed.
+    public var isDisposed: Bool {
+        isFlagSet(self.disposed, 1)
+    }
+
+    /// Constructs a new disposable with the given action used for disposal.
+    ///
+    /// - parameter disposeAction: Disposal action which will be run upon calling `dispose`.
+    private init(_ disposeAction: @escaping DisposeAction) {
+        self.disposeAction = disposeAction
+        super.init()
+    }
+
+    // Non-deprecated version of the constructor, used by `Disposables.create(with:)`
+    fileprivate init(disposeAction: @escaping DisposeAction) {
+        self.disposeAction = disposeAction
+        super.init()
+    }
+
+    /// Calls the disposal action if and only if the current instance hasn't been disposed yet.
+    ///
+    /// After invoking disposal action, disposal action will be dereferenced.
+    fileprivate func dispose() {
+        if fetchOr(self.disposed, 1) == 0 {
+            if let action = self.disposeAction {
+                self.disposeAction = nil
+                action()
+            }
+        }
+    }
+}
+
+extension Disposables {
+
+    /// Constructs a new disposable with the given action used for disposal.
+    ///
+    /// - parameter dispose: Disposal action which will be run upon calling `dispose`.
+    public static func create(with dispose: @escaping () -> Void) -> Cancelable {
+        AnonymousDisposable(disposeAction: dispose)
+    }
+
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Disposables/BinaryDisposable.swift

@@ -0,0 +1,53 @@
+//
+//  BinaryDisposable.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 6/12/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Represents two disposable resources that are disposed together.
+private final class BinaryDisposable : DisposeBase, Cancelable {
+
+    private let disposed = AtomicInt(0)
+
+    // state
+    private var disposable1: Disposable?
+    private var disposable2: Disposable?
+
+    /// - returns: Was resource disposed.
+    var isDisposed: Bool {
+        isFlagSet(self.disposed, 1)
+    }
+
+    /// Constructs new binary disposable from two disposables.
+    ///
+    /// - parameter disposable1: First disposable
+    /// - parameter disposable2: Second disposable
+    init(_ disposable1: Disposable, _ disposable2: Disposable) {
+        self.disposable1 = disposable1
+        self.disposable2 = disposable2
+        super.init()
+    }
+
+    /// Calls the disposal action if and only if the current instance hasn't been disposed yet.
+    ///
+    /// After invoking disposal action, disposal action will be dereferenced.
+    func dispose() {
+        if fetchOr(self.disposed, 1) == 0 {
+            self.disposable1?.dispose()
+            self.disposable2?.dispose()
+            self.disposable1 = nil
+            self.disposable2 = nil
+        }
+    }
+}
+
+extension Disposables {
+
+    /// Creates a disposable with the given disposables.
+    public static func create(_ disposable1: Disposable, _ disposable2: Disposable) -> Cancelable {
+        BinaryDisposable(disposable1, disposable2)
+    }
+
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Disposables/BooleanDisposable.swift

@@ -0,0 +1,34 @@
+//
+//  BooleanDisposable.swift
+//  RxSwift
+//
+//  Created by Junior B. on 10/29/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Represents a disposable resource that can be checked for disposal status.
+public final class BooleanDisposable : Cancelable {
+
+    internal static let BooleanDisposableTrue = BooleanDisposable(isDisposed: true)
+    private let disposed: AtomicInt
+    
+    /// Initializes a new instance of the `BooleanDisposable` class
+    public init() {
+        disposed = AtomicInt(0)
+    }
+    
+    /// Initializes a new instance of the `BooleanDisposable` class with given value
+    public init(isDisposed: Bool) {
+        self.disposed = AtomicInt(isDisposed ? 1 : 0)
+    }
+    
+    /// - returns: Was resource disposed.
+    public var isDisposed: Bool {
+        isFlagSet(self.disposed, 1)
+    }
+    
+    /// Sets the status to disposed, which can be observer through the `isDisposed` property.
+    public func dispose() {
+        fetchOr(self.disposed, 1)
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Disposables/CompositeDisposable.swift

@@ -0,0 +1,147 @@
+//
+//  CompositeDisposable.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 2/20/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Represents a group of disposable resources that are disposed together.
+public final class CompositeDisposable : DisposeBase, Cancelable {
+    /// Key used to remove disposable from composite disposable
+    public struct DisposeKey {
+        fileprivate let key: BagKey
+        fileprivate init(key: BagKey) {
+            self.key = key
+        }
+    }
+
+    private var lock = SpinLock()
+    
+    // state
+    private var disposables: Bag<Disposable>? = Bag()
+
+    public var isDisposed: Bool {
+        self.lock.performLocked { self.disposables == nil }
+    }
+    
+    public override init() {
+    }
+    
+    /// Initializes a new instance of composite disposable with the specified number of disposables.
+    public init(_ disposable1: Disposable, _ disposable2: Disposable) {
+        // This overload is here to make sure we are using optimized version up to 4 arguments.
+        _ = self.disposables!.insert(disposable1)
+        _ = self.disposables!.insert(disposable2)
+    }
+    
+    /// Initializes a new instance of composite disposable with the specified number of disposables.
+    public init(_ disposable1: Disposable, _ disposable2: Disposable, _ disposable3: Disposable) {
+        // This overload is here to make sure we are using optimized version up to 4 arguments.
+        _ = self.disposables!.insert(disposable1)
+        _ = self.disposables!.insert(disposable2)
+        _ = self.disposables!.insert(disposable3)
+    }
+    
+    /// Initializes a new instance of composite disposable with the specified number of disposables.
+    public init(_ disposable1: Disposable, _ disposable2: Disposable, _ disposable3: Disposable, _ disposable4: Disposable, _ disposables: Disposable...) {
+        // This overload is here to make sure we are using optimized version up to 4 arguments.
+        _ = self.disposables!.insert(disposable1)
+        _ = self.disposables!.insert(disposable2)
+        _ = self.disposables!.insert(disposable3)
+        _ = self.disposables!.insert(disposable4)
+        
+        for disposable in disposables {
+            _ = self.disposables!.insert(disposable)
+        }
+    }
+    
+    /// Initializes a new instance of composite disposable with the specified number of disposables.
+    public init(disposables: [Disposable]) {
+        for disposable in disposables {
+            _ = self.disposables!.insert(disposable)
+        }
+    }
+
+    /**
+     Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed.
+     
+     - parameter disposable: Disposable to add.
+     - returns: Key that can be used to remove disposable from composite disposable. In case dispose bag was already
+     disposed `nil` will be returned.
+     */
+    public func insert(_ disposable: Disposable) -> DisposeKey? {
+        let key = self._insert(disposable)
+        
+        if key == nil {
+            disposable.dispose()
+        }
+        
+        return key
+    }
+    
+    private func _insert(_ disposable: Disposable) -> DisposeKey? {
+        self.lock.performLocked {
+            let bagKey = self.disposables?.insert(disposable)
+            return bagKey.map(DisposeKey.init)
+        }
+    }
+    
+    /// - returns: Gets the number of disposables contained in the `CompositeDisposable`.
+    public var count: Int {
+        self.lock.performLocked { self.disposables?.count ?? 0 }
+    }
+    
+    /// Removes and disposes the disposable identified by `disposeKey` from the CompositeDisposable.
+    ///
+    /// - parameter disposeKey: Key used to identify disposable to be removed.
+    public func remove(for disposeKey: DisposeKey) {
+        self._remove(for: disposeKey)?.dispose()
+    }
+    
+    private func _remove(for disposeKey: DisposeKey) -> Disposable? {
+        self.lock.performLocked { self.disposables?.removeKey(disposeKey.key) }
+    }
+    
+    /// Disposes all disposables in the group and removes them from the group.
+    public func dispose() {
+        if let disposables = self._dispose() {
+            disposeAll(in: disposables)
+        }
+    }
+
+    private func _dispose() -> Bag<Disposable>? {
+        self.lock.performLocked {
+            let current = self.disposables
+            self.disposables = nil
+            return current
+        }
+    }
+}
+
+extension Disposables {
+
+    /// Creates a disposable with the given disposables.
+    public static func create(_ disposable1: Disposable, _ disposable2: Disposable, _ disposable3: Disposable) -> Cancelable {
+        CompositeDisposable(disposable1, disposable2, disposable3)
+    }
+    
+    /// Creates a disposable with the given disposables.
+    public static func create(_ disposable1: Disposable, _ disposable2: Disposable, _ disposable3: Disposable, _ disposables: Disposable ...) -> Cancelable {
+        var disposables = disposables
+        disposables.append(disposable1)
+        disposables.append(disposable2)
+        disposables.append(disposable3)
+        return CompositeDisposable(disposables: disposables)
+    }
+    
+    /// Creates a disposable with the given disposables.
+    public static func create(_ disposables: [Disposable]) -> Cancelable {
+        switch disposables.count {
+        case 2:
+            return Disposables.create(disposables[0], disposables[1])
+        default:
+            return CompositeDisposable(disposables: disposables)
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+//
+//  Disposables.swift
+//  RxSwift
+//
+//  Created by Mohsen Ramezanpoor on 01/08/2016.
+//  Copyright © 2016 Krunoslav Zaher. All rights reserved.
+//
+
+/// A collection of utility methods for common disposable operations.
+public struct Disposables {
+    private init() {}
+}
+

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Disposables/DisposeBag.swift

@@ -0,0 +1,144 @@
+//
+//  DisposeBag.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 3/25/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+extension Disposable {
+    /// Adds `self` to `bag`
+    ///
+    /// - parameter bag: `DisposeBag` to add `self` to.
+    public func disposed(by bag: DisposeBag) {
+        bag.insert(self)
+    }
+}
+
+/**
+Thread safe bag that disposes added disposables on `deinit`.
+
+This returns ARC (RAII) like resource management to `RxSwift`.
+
+In case contained disposables need to be disposed, just put a different dispose bag
+or create a new one in its place.
+
+    self.existingDisposeBag = DisposeBag()
+
+In case explicit disposal is necessary, there is also `CompositeDisposable`.
+*/
+public final class DisposeBag: DisposeBase {
+    
+    private var lock = SpinLock()
+    
+    // state
+    private var disposables = [Disposable]()
+    private var isDisposed = false
+    
+    /// Constructs new empty dispose bag.
+    public override init() {
+        super.init()
+    }
+
+    /// Adds `disposable` to be disposed when dispose bag is being deinited.
+    ///
+    /// - parameter disposable: Disposable to add.
+    public func insert(_ disposable: Disposable) {
+        self._insert(disposable)?.dispose()
+    }
+    
+    private func _insert(_ disposable: Disposable) -> Disposable? {
+        self.lock.performLocked {
+            if self.isDisposed {
+                return disposable
+            }
+
+            self.disposables.append(disposable)
+
+            return nil
+        }
+    }
+
+    /// This is internal on purpose, take a look at `CompositeDisposable` instead.
+    private func dispose() {
+        let oldDisposables = self._dispose()
+
+        for disposable in oldDisposables {
+            disposable.dispose()
+        }
+    }
+
+    private func _dispose() -> [Disposable] {
+        self.lock.performLocked {
+            let disposables = self.disposables
+            
+            self.disposables.removeAll(keepingCapacity: false)
+            self.isDisposed = true
+            
+            return disposables
+        }
+    }
+    
+    deinit {
+        self.dispose()
+    }
+}
+
+extension DisposeBag {
+    /// Convenience init allows a list of disposables to be gathered for disposal.
+    public convenience init(disposing disposables: Disposable...) {
+        self.init()
+        self.disposables += disposables
+    }
+
+    /// Convenience init which utilizes a function builder to let you pass in a list of
+    /// disposables to make a DisposeBag of.
+    public convenience init(@DisposableBuilder builder: () -> [Disposable]) {
+      self.init(disposing: builder())
+    }
+
+    /// Convenience init allows an array of disposables to be gathered for disposal.
+    public convenience init(disposing disposables: [Disposable]) {
+        self.init()
+        self.disposables += disposables
+    }
+
+    /// Convenience function allows a list of disposables to be gathered for disposal.
+    public func insert(_ disposables: Disposable...) {
+        self.insert(disposables)
+    }
+
+    /// Convenience function allows a list of disposables to be gathered for disposal.
+    public func insert(@DisposableBuilder builder: () -> [Disposable]) {
+        self.insert(builder())
+    }
+
+    /// Convenience function allows an array of disposables to be gathered for disposal.
+    public func insert(_ disposables: [Disposable]) {
+        self.lock.performLocked {
+            if self.isDisposed {
+                disposables.forEach { $0.dispose() }
+            } else {
+                self.disposables += disposables
+            }
+        }
+    }
+
+    /// A function builder accepting a list of Disposables and returning them as an array.
+    #if swift(>=5.4)
+    @resultBuilder
+    public struct DisposableBuilder {
+      public static func buildBlock(_ disposables: Disposable...) -> [Disposable] {
+        return disposables
+      }
+    }
+    #else
+    @_functionBuilder
+    public struct DisposableBuilder {
+      public static func buildBlock(_ disposables: Disposable...) -> [Disposable] {
+        return disposables
+      }
+    }
+    #endif
+    
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Disposables/DisposeBase.swift

@@ -0,0 +1,22 @@
+//
+//  DisposeBase.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 4/4/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Base class for all disposables.
+public class DisposeBase {
+    init() {
+#if TRACE_RESOURCES
+    _ = Resources.incrementTotal()
+#endif
+    }
+    
+    deinit {
+#if TRACE_RESOURCES
+    _ = Resources.decrementTotal()
+#endif
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxSwift/Disposables/NopDisposable.swift

@@ -0,0 +1,30 @@
+//
+//  NopDisposable.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 2/15/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+/// Represents a disposable that does nothing on disposal.
+///
+/// Nop = No Operation
+private struct NopDisposable : Disposable {
+ 
+    fileprivate static let noOp: Disposable = NopDisposable()
+    
+    private init() {
+        
+    }
+    
+    /// Does nothing.
+    public func dispose() {
+    }
+}
+
+extension Disposables {
+    /**
+     Creates a disposable that does nothing on disposal.
+     */
+    static public func create() -> Disposable { NopDisposable.noOp }
+}