Add new pods.

- RxSwift
- RXCocoa

Pods/RxSwift/RxSwift/Observers/AnonymousObserver.swift

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

Pods/RxSwift/RxSwift/Observers/ObserverBase.swift

@@ -0,0 +1,39 @@
+//
+//  ObserverBase.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 2/15/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+import Foundation
+
+class ObserverBase<ElementType> : Disposable, ObserverType {
+    typealias E = ElementType
+
+    private var _isStopped: AtomicInt = 0
+
+    func on(_ event: Event<E>) {
+        switch event {
+        case .next:
+            if _isStopped == 0 {
+                onCore(event)
+            }
+        case .error, .completed:
+
+            if !AtomicCompareAndSwap(0, 1, &_isStopped) {
+                return
+            }
+
+            onCore(event)
+        }
+    }
+
+    func onCore(_ event: Event<E>) {
+        abstractMethod()
+    }
+
+    func dispose() {
+        _ = AtomicCompareAndSwap(0, 1, &_isStopped)
+    }
+}

Pods/RxSwift/RxSwift/Observers/TailRecursiveSink.swift

@@ -0,0 +1,152 @@
+//
+//  TailRecursiveSink.swift
+//  RxSwift
+//
+//  Created by Krunoslav Zaher on 3/21/15.
+//  Copyright © 2015 Krunoslav Zaher. All rights reserved.
+//
+
+import Foundation
+
+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<S: Sequence, O: ObserverType>
+    : Sink<O>
+    , InvocableWithValueType where S.Iterator.Element: ObservableConvertibleType, S.Iterator.Element.E == O.E {
+    typealias Value = TailRecursiveSinkCommand
+    typealias E = O.E
+    typealias SequenceGenerator = (generator: S.Iterator, remaining: IntMax?)
+
+    var _generators: [SequenceGenerator] = []
+    var _isDisposed = false
+    var _subscription = SerialDisposable()
+
+    // this is thread safe object
+    var _gate = AsyncLock<InvocableScheduledItem<TailRecursiveSink<S, O>>>()
+
+    override init(observer: O, cancel: Cancelable) {
+        super.init(observer: observer, cancel: cancel)
+    }
+
+    func run(_ sources: SequenceGenerator) -> Disposable {
+        _generators.append(sources)
+
+        schedule(.moveNext)
+
+        return _subscription
+    }
+
+    func invoke(_ command: TailRecursiveSinkCommand) {
+        switch command {
+        case .dispose:
+            disposeCommand()
+        case .moveNext:
+            moveNextCommand()
+        }
+    }
+
+    // simple implementation for now
+    func schedule(_ command: TailRecursiveSinkCommand) {
+        _gate.invoke(InvocableScheduledItem(invocable: self, state: command))
+    }
+
+    func done() {
+        forwardOn(.completed)
+        dispose()
+    }
+
+    func extract(_ observable: Observable<E>) -> SequenceGenerator? {
+        abstractMethod()
+    }
+
+    // should be done on gate locked
+
+    private func moveNextCommand() {
+        var next: Observable<E>? = nil
+
+        repeat {
+            guard let (g, left) = _generators.last else {
+                break
+            }
+            
+            if _isDisposed {
+                return
+            }
+
+            _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 {
+                    _generators.append((e, knownOriginalLeft - 1))
+                }
+            }
+            else {
+                _generators.append((e, nil))
+            }
+
+            let nextGenerator = extract(nextCandidate)
+
+            if let nextGenerator = nextGenerator {
+                _generators.append(nextGenerator)
+                #if DEBUG || TRACE_RESOURCES
+                    if maxTailRecursiveSinkStackSize < _generators.count {
+                        maxTailRecursiveSinkStackSize = _generators.count
+                    }
+                #endif
+            }
+            else {
+                next = nextCandidate
+            }
+        } while next == nil
+
+        if next == nil  {
+            done()
+            return
+        }
+
+        let disposable = SingleAssignmentDisposable()
+        _subscription.disposable = disposable
+        disposable.setDisposable(subscribeToNext(next!))
+    }
+
+    func subscribeToNext(_ source: Observable<E>) -> Disposable {
+        abstractMethod()
+    }
+
+    func disposeCommand() {
+        _isDisposed = true
+        _generators.removeAll(keepingCapacity: false)
+    }
+
+    override func dispose() {
+        super.dispose()
+        
+        _subscription.dispose()
+        
+        schedule(.dispose)
+    }
+}
+