Add new pods.

- RxSwift
- RXCocoa

Pods/RxSwift/Platform/DataStructures/Bag.swift

@@ -0,0 +1,167 @@
+//
+//  Bag.swift
+//  Platform
+//
+//  Created by Krunoslav Zaher on 2/28/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+import Foundation
+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 an 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)
+ 
+    fileprivate var _nextKey: BagKey = BagKey(rawValue: 0)
+
+    // data
+
+    // first fill inline variables
+    var _key0: BagKey? = nil
+    var _value0: T? = nil
+
+    // last is sparse dictionary
+    var _dictionary: [BagKey : T]? = nil
+
+    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 _dictionary == nil {
+            _dictionary = [:]
+        }
+
+        _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) + dictionaryCount
+    }
+    
+    /// Removes all elements from bag and clears capacity.
+    mutating func removeAll() {
+        _key0 = nil
+        _value0 = nil
+
+        _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
+        }
+
+        return nil
+    }
+}
+
+extension Bag {
+    /// A textual representation of `self`, suitable for debugging.
+    var debugDescription : String {
+        return "\(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)
+        }
+
+        if dictionary?.count ?? 0 > 0 {
+            for element in dictionary!.values {
+                action(element)
+            }
+        }
+    }
+}
+
+extension BagKey: Hashable {
+    var hashValue: Int {
+        return rawValue.hashValue
+    }
+}
+
+func ==(lhs: BagKey, rhs: BagKey) -> Bool {
+    return lhs.rawValue == rhs.rawValue
+}

Pods/RxSwift/Platform/DataStructures/InfiniteSequence.swift

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

Pods/RxSwift/Platform/DataStructures/PriorityQueue.swift

@@ -0,0 +1,114 @@
+//
+//  PriorityQueue.swift
+//  Platform
+//
+//  Created by Krunoslav Zaher on 12/27/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+import Foundation
+
+struct PriorityQueue<Element> {
+    private let _hasHigherPriority: (Element, Element) -> Bool
+    private let _isEqual: (Element, Element) -> Bool
+
+    fileprivate var _elements = [Element]()
+
+    init(hasHigherPriority: @escaping (Element, Element) -> Bool, isEqual: @escaping (Element, Element) -> Bool) {
+        _hasHigherPriority = hasHigherPriority
+        _isEqual = isEqual
+    }
+
+    mutating func enqueue(_ element: Element) {
+        _elements.append(element)
+        bubbleToHigherPriority(_elements.count - 1)
+    }
+
+    func peek() -> Element? {
+        return _elements.first
+    }
+
+    var isEmpty: Bool {
+        return _elements.count == 0
+    }
+
+    mutating func dequeue() -> Element? {
+        guard let front = peek() else {
+            return nil
+        }
+
+        removeAt(0)
+
+        return front
+    }
+
+    mutating func remove(_ element: Element) {
+        for i in 0 ..< _elements.count {
+            if _isEqual(_elements[i], element) {
+                removeAt(i)
+                return
+            }
+        }
+    }
+
+    private mutating func removeAt(_ index: Int) {
+        let removingLast = index == _elements.count - 1
+        if !removingLast {
+            swap(&_elements[index], &_elements[_elements.count - 1])
+        }
+
+        _ = _elements.popLast()
+
+        if !removingLast {
+            bubbleToHigherPriority(index)
+            bubbleToLowerPriority(index)
+        }
+    }
+
+    private mutating func bubbleToHigherPriority(_ initialUnbalancedIndex: Int) {
+        precondition(initialUnbalancedIndex >= 0)
+        precondition(initialUnbalancedIndex < _elements.count)
+
+        var unbalancedIndex = initialUnbalancedIndex
+
+        while unbalancedIndex > 0 {
+            let parentIndex = (unbalancedIndex - 1) / 2
+            guard _hasHigherPriority(_elements[unbalancedIndex], _elements[parentIndex]) else { break }
+            
+            swap(&_elements[unbalancedIndex], &_elements[parentIndex])
+            unbalancedIndex = parentIndex
+        }
+    }
+
+    private mutating func bubbleToLowerPriority(_ initialUnbalancedIndex: Int) {
+        precondition(initialUnbalancedIndex >= 0)
+        precondition(initialUnbalancedIndex < _elements.count)
+
+        var unbalancedIndex = initialUnbalancedIndex
+        while true {
+            let leftChildIndex = unbalancedIndex * 2 + 1
+            let rightChildIndex = unbalancedIndex * 2 + 2
+
+            var highestPriorityIndex = unbalancedIndex
+
+            if leftChildIndex < _elements.count && _hasHigherPriority(_elements[leftChildIndex], _elements[highestPriorityIndex]) {
+                highestPriorityIndex = leftChildIndex
+            }
+
+            if rightChildIndex < _elements.count && _hasHigherPriority(_elements[rightChildIndex], _elements[highestPriorityIndex]) {
+                highestPriorityIndex = rightChildIndex
+            }
+
+            guard highestPriorityIndex != unbalancedIndex else { break }
+
+            swap(&_elements[highestPriorityIndex], &_elements[unbalancedIndex])
+            unbalancedIndex = highestPriorityIndex
+        }
+    }
+}
+
+extension PriorityQueue : CustomDebugStringConvertible {
+    var debugDescription: String {
+        return _elements.debugDescription
+    }
+}

Pods/RxSwift/Platform/DataStructures/Queue.swift

@@ -0,0 +1,154 @@
+//
+//  Queue.swift
+//  Platform
+//
+//  Created by Krunoslav Zaher on 3/21/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+import Foundation
+
+/**
+Data structure that represents queue.
+
+Complexity of `enqueue`, `dequeue` is O(1) when number of operations is
+averaged over N operations.
+
+Complexity of `peek` is O(1).
+*/
+struct Queue<T>: Sequence {
+    /// Type of generator.
+    typealias Generator = AnyIterator<T>
+
+    private let _resizeFactor = 2
+    
+    private var _storage: ContiguousArray<T?>
+    private var _count = 0
+    private var _pushNextIndex = 0
+    private let _initialCapacity: Int
+
+    /**
+    Creates new queue.
+    
+    - parameter capacity: Capacity of newly created queue.
+    */
+    init(capacity: Int) {
+        _initialCapacity = capacity
+
+        _storage = ContiguousArray<T?>(repeating: nil, count: capacity)
+    }
+    
+    private var dequeueIndex: Int {
+        let index = _pushNextIndex - count
+        return index < 0 ? index + _storage.count : index
+    }
+    
+    /// - returns: Is queue empty.
+    var isEmpty: Bool {
+        return count == 0
+    }
+    
+    /// - returns: Number of elements inside queue.
+    var count: Int {
+        return _count
+    }
+    
+    /// - returns: Element in front of a list of elements to `dequeue`.
+    func peek() -> T {
+        precondition(count > 0)
+        
+        return _storage[dequeueIndex]!
+    }
+    
+    mutating private func resizeTo(_ size: Int) {
+        var newStorage = ContiguousArray<T?>(repeating: nil, count: size)
+        
+        let count = _count
+        
+        let dequeueIndex = self.dequeueIndex
+        let spaceToEndOfQueue = _storage.count - dequeueIndex
+        
+        // first batch is from dequeue index to end of array
+        let countElementsInFirstBatch = Swift.min(count, spaceToEndOfQueue)
+        // second batch is wrapped from start of array to end of queue
+        let numberOfElementsInSecondBatch = count - countElementsInFirstBatch
+        
+        newStorage[0 ..< countElementsInFirstBatch] = _storage[dequeueIndex ..< (dequeueIndex + countElementsInFirstBatch)]
+        newStorage[countElementsInFirstBatch ..< (countElementsInFirstBatch + numberOfElementsInSecondBatch)] = _storage[0 ..< numberOfElementsInSecondBatch]
+        
+        _count = count
+        _pushNextIndex = count
+        _storage = newStorage
+    }
+    
+    /// Enqueues `element`.
+    ///
+    /// - parameter element: Element to enqueue.
+    mutating func enqueue(_ element: T) {
+        if count == _storage.count {
+            resizeTo(Swift.max(_storage.count, 1) * _resizeFactor)
+        }
+        
+        _storage[_pushNextIndex] = element
+        _pushNextIndex += 1
+        _count += 1
+        
+        if _pushNextIndex >= _storage.count {
+            _pushNextIndex -= _storage.count
+        }
+    }
+    
+    private mutating func dequeueElementOnly() -> T {
+        precondition(count > 0)
+        
+        let index = dequeueIndex
+
+        defer {
+            _storage[index] = nil
+            _count -= 1
+        }
+
+        return _storage[index]!
+    }
+
+    /// Dequeues element or throws an exception in case queue is empty.
+    ///
+    /// - returns: Dequeued element.
+    mutating func dequeue() -> T? {
+        if self.count == 0 {
+            return nil
+        }
+
+        defer {
+            let downsizeLimit = _storage.count / (_resizeFactor * _resizeFactor)
+            if _count < downsizeLimit && downsizeLimit >= _initialCapacity {
+                resizeTo(_storage.count / _resizeFactor)
+            }
+        }
+
+        return dequeueElementOnly()
+    }
+    
+    /// - returns: Generator of contained elements.
+    func makeIterator() -> AnyIterator<T> {
+        var i = dequeueIndex
+        var count = _count
+
+        return AnyIterator {
+            if count == 0 {
+                return nil
+            }
+
+            defer {
+                count -= 1
+                i += 1
+            }
+
+            if i >= self._storage.count {
+                i -= self._storage.count
+            }
+
+            return self._storage[i]
+        }
+    }
+}