0001    //
0002    //  TakeUntil.swift
0003    //  RxSwift
0004    //
0005    //  Created by Krunoslav Zaher on 6/7/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    class TakeUntilSinkOther
TakeUntil.swift:96
        let otherObserver = TakeUntilSinkOther(parent: self)
<ElementType
TakeUntil.swift:15
    typealias Parent = TakeUntilSink<ElementType, Other, O>
, Other
TakeUntil.swift:15
    typealias Parent = TakeUntilSink<ElementType, Other, O>
TakeUntil.swift:16
    typealias E = Other
, O
TakeUntil.swift:15
    typealias Parent = TakeUntilSink<ElementType, Other, O>
: ObserverType where O.E == ElementType>
0012        : ObserverType
0013        , LockOwnerType
0014        , SynchronizedOnType {
0015        typealias Parent
TakeUntil.swift:18
    private let _parent: Parent
TakeUntil.swift:26
    init(parent: Parent) {
 = TakeUntilSink<ElementType, Other, O>
0016        typealias E
TakeUntil.swift:33
    func on(event: Event<E>) {
TakeUntil.swift:37
    func _synchronized_on(event: Event<E>) {
 = Other
0017        
0018        private let _parent
TakeUntil.swift:21
        return _parent._lock
TakeUntil.swift:27
        _parent = parent
TakeUntil.swift:40
            _parent.forwardOn(.Completed)
TakeUntil.swift:41
            _parent.dispose()
TakeUntil.swift:43
            _parent.forwardOn(.Error(e))
TakeUntil.swift:44
            _parent.dispose()
TakeUntil.swift:46
            _parent._open = true
: Parent
0019    
0020        var _lock: NSRecursiveLock {
0021            return _parent._lock
0022        }
0023        
0024        private let _subscription
TakeUntil.swift:47
            _subscription.dispose()
TakeUntil.swift:98
        otherObserver._subscription.disposable = otherSubscription
TakeUntil.swift:101
        return StableCompositeDisposable.create(sourceSubscription, otherObserver._subscription)
 = SingleAssignmentDisposable()
0025        
0026        init
TakeUntil.swift:96
        let otherObserver = TakeUntilSinkOther(parent: self)
(parent: Parent) {
0027            _parent = parent
0028    #if TRACE_RESOURCES
0029            AtomicIncrement(&resourceCount)
0030    #endif
0031        }
0032        
0033        func on(event: Event<E>) {
0034            synchronizedOn(event)
0035        }
0036    
0037        func _synchronized_on(event: Event<E>) {
0038            switch event {
0039            case .Next:
0040                _parent.forwardOn(.Completed)
0041                _parent.dispose()
0042            case .Error(let e):
0043                _parent.forwardOn(.Error(e))
0044                _parent.dispose()
0045            case .Completed:
0046                _parent._open = true
0047                _subscription.dispose()
0048            }
0049        }
0050        
0051    #if TRACE_RESOURCES
0052        deinit {
0053            AtomicDecrement(&resourceCount)
0054        }
0055    #endif
0056    }
0057    
0058    class TakeUntilSink
TakeUntil.swift:15
    typealias Parent = TakeUntilSink<ElementType, Other, O>
TakeUntil.swift:116
        let sink = TakeUntilSink(parent: self, observer: observer)
<ElementType
TakeUntil.swift:63
    typealias E = ElementType
, Other
TakeUntil.swift:64
    typealias Parent = TakeUntil<E, Other>
, O
TakeUntil.swift:59
    : Sink<O>
TakeUntil.swift:73
    init(parent: Parent, observer: O) {
: ObserverType where O.E == ElementType>
0059        : Sink<O>
0060        , LockOwnerType
0061        , ObserverType
0062        , SynchronizedOnType {
0063        typealias E
TakeUntil.swift:64
    typealias Parent = TakeUntil<E, Other>
TakeUntil.swift:78
    func on(event: Event<E>) {
TakeUntil.swift:82
    func _synchronized_on(event: Event<E>) {
 = ElementType
0064        typealias Parent
TakeUntil.swift:66
    private let _parent: Parent
TakeUntil.swift:73
    init(parent: Parent, observer: O) {
 = TakeUntil<E, Other>
0065        
0066        private let _parent
TakeUntil.swift:74
        _parent = parent
TakeUntil.swift:97
        let otherSubscription = _parent._other.subscribe(otherObserver)
TakeUntil.swift:99
        let sourceSubscription = _parent._source.subscribe(self)
: Parent
0067     
0068        let _lock
TakeUntil.swift:21
        return _parent._lock
 = NSRecursiveLock()
0069        
0070        // state
0071        private var _open
TakeUntil.swift:46
            _parent._open = true
 = false
0072        
0073        init
TakeUntil.swift:116
        let sink = TakeUntilSink(parent: self, observer: observer)
(parent: Parent, observer: O) {
0074            _parent = parent
0075            super.init(observer: observer)
0076        }
0077        
0078        func on(event: Event<E>) {
0079            synchronizedOn(event)
0080        }
0081    
0082        func _synchronized_on(event: Event<E>) {
0083            switch event {
0084            case .Next:
0085                forwardOn(event)
0086            case .Error:
0087                forwardOn(event)
0088                dispose()
0089            case .Completed:
0090                forwardOn(event)
0091                dispose()
0092            }
0093        }
0094        
0095        func run
TakeUntil.swift:117
        sink.disposable = sink.run()
() -> Disposable {
0096            let otherObserver = TakeUntilSinkOther(parent: self)
0097            let otherSubscription = _parent._other.subscribe(otherObserver)
0098            otherObserver._subscription.disposable = otherSubscription
0099            let sourceSubscription = _parent._source.subscribe(self)
0100            
0101            return StableCompositeDisposable.create(sourceSubscription, otherObserver._subscription)
0102        }
0103    }
0104    
0105    class TakeUntil
Observable+Multiple.swift:241
        return TakeUntil(source: asObservable(), other: other.asObservable())
TakeUntil.swift:64
    typealias Parent = TakeUntil<E, Other>
<Element
TakeUntil.swift:105
class TakeUntil<Element, Other>: Producer<Element> {
TakeUntil.swift:107
    private let _source: Observable<Element>
TakeUntil.swift:110
    init(source: Observable<Element>, other: Observable<Other>) {
TakeUntil.swift:115
    override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
, Other
TakeUntil.swift:108
    private let _other: Observable<Other>
TakeUntil.swift:110
    init(source: Observable<Element>, other: Observable<Other>) {
>: Producer<Element> {
0106        
0107        private let _source
TakeUntil.swift:99
        let sourceSubscription = _parent._source.subscribe(self)
TakeUntil.swift:111
        _source = source
: Observable<Element>
0108        private let _other
TakeUntil.swift:97
        let otherSubscription = _parent._other.subscribe(otherObserver)
TakeUntil.swift:112
        _other = other
: Observable<Other>
0109        
0110        init
Observable+Multiple.swift:241
        return TakeUntil(source: asObservable(), other: other.asObservable())
(source: Observable<Element>, other: Observable<Other>) {
0111            _source = source
0112            _other = other
0113        }
0114        
0115        override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
0116            let sink = TakeUntilSink(parent: self, observer: observer)
0117            sink.disposable = sink.run()
0118            return sink
0119        }
0120    }