0001    //
0002    //  RetryWhen.swift
0003    //  Rx
0004    //
0005    //  Created by Junior B. on 06/10/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    class RetryTriggerSink
RetryWhen.swift:62
                let errorHandlerSubscription = _parent._notifier.subscribe(RetryTriggerSink(parent: self))
<S
RetryWhen.swift:15
    typealias Parent = RetryWhenSequenceSinkIter<S, O, TriggerObservable, Error>
: SequenceType, O
RetryWhen.swift:15
    typealias Parent = RetryWhenSequenceSinkIter<S, O, TriggerObservable, Error>
: ObserverType, TriggerObservable
RetryWhen.swift:13
    typealias E = TriggerObservable.E
RetryWhen.swift:15
    typealias Parent = RetryWhenSequenceSinkIter<S, O, TriggerObservable, Error>
: ObservableType, Error
RetryWhen.swift:15
    typealias Parent = RetryWhenSequenceSinkIter<S, O, TriggerObservable, Error>
 where S.Generator.Element : ObservableType, S.Generator.Element.E == O.E>
0012        : ObserverType {
0013        typealias E
RetryWhen.swift:23
    func on(event: Event<E>) {
 = TriggerObservable.E
0014        
0015        typealias Parent
RetryWhen.swift:17
    private let _parent: Parent
RetryWhen.swift:19
    init(parent: Parent) {
 = RetryWhenSequenceSinkIter<S, O, TriggerObservable, Error>
0016        
0017        private let _parent
RetryWhen.swift:20
        _parent = parent
RetryWhen.swift:26
            _parent._parent._lastError = nil
RetryWhen.swift:27
            _parent._parent.schedule(.MoveNext)
RetryWhen.swift:29
            _parent._parent.forwardOn(.Error(e))
RetryWhen.swift:30
            _parent._parent.dispose()
RetryWhen.swift:32
            _parent._parent.forwardOn(.Completed)
RetryWhen.swift:33
            _parent._parent.dispose()
: Parent
0018    
0019        init
RetryWhen.swift:62
                let errorHandlerSubscription = _parent._notifier.subscribe(RetryTriggerSink(parent: self))
(parent: Parent) {
0020            _parent = parent
0021        }
0022    
0023        func on(event: Event<E>) {
0024            switch event {
0025            case .Next:
0026                _parent._parent._lastError = nil
0027                _parent._parent.schedule(.MoveNext)
0028            case .Error(let e):
0029                _parent._parent.forwardOn(.Error(e))
0030                _parent._parent.dispose()
0031            case .Completed:
0032                _parent._parent.forwardOn(.Completed)
0033                _parent._parent.dispose()
0034            }
0035        }
0036    }
0037    
0038    class RetryWhenSequenceSinkIter
RetryWhen.swift:15
    typealias Parent = RetryWhenSequenceSinkIter<S, O, TriggerObservable, Error>
RetryWhen.swift:122
        let iter = RetryWhenSequenceSinkIter(parent: self)
<S
RetryWhen.swift:42
    typealias Parent = RetryWhenSequenceSink<S, O, TriggerObservable, Error>
: SequenceType, O
RetryWhen.swift:41
    typealias E = O.E
RetryWhen.swift:42
    typealias Parent = RetryWhenSequenceSink<S, O, TriggerObservable, Error>
: ObserverType, TriggerObservable
RetryWhen.swift:42
    typealias Parent = RetryWhenSequenceSink<S, O, TriggerObservable, Error>
: ObservableType, Error
RetryWhen.swift:42
    typealias Parent = RetryWhenSequenceSink<S, O, TriggerObservable, Error>
RetryWhen.swift:58
            if let failedWith = error as? Error {
 where S.Generator.Element : ObservableType, S.Generator.Element.E == O.E>
0039        : SingleAssignmentDisposable
0040        , ObserverType {
0041        typealias E
RetryWhen.swift:51
    func on(event: Event<E>) {
 = O.E
0042        typealias Parent
RetryWhen.swift:44
    private let _parent: Parent
RetryWhen.swift:47
    init(parent: Parent) {
 = RetryWhenSequenceSink<S, O, TriggerObservable, Error>
0043    
0044        private let _parent
RetryWhen.swift:26
            _parent._parent._lastError = nil
RetryWhen.swift:27
            _parent._parent.schedule(.MoveNext)
RetryWhen.swift:29
            _parent._parent.forwardOn(.Error(e))
RetryWhen.swift:30
            _parent._parent.dispose()
RetryWhen.swift:32
            _parent._parent.forwardOn(.Completed)
RetryWhen.swift:33
            _parent._parent.dispose()
RetryWhen.swift:48
        _parent = parent
RetryWhen.swift:54
            _parent.forwardOn(event)
RetryWhen.swift:56
            _parent._lastError = error
RetryWhen.swift:62
                let errorHandlerSubscription = _parent._notifier.subscribe(RetryTriggerSink(parent: self))
RetryWhen.swift:64
                _parent._errorSubject.on(.Next(failedWith))
RetryWhen.swift:67
                _parent.forwardOn(.Error(error))
RetryWhen.swift:68
                _parent.dispose()
RetryWhen.swift:71
            _parent.forwardOn(event)
RetryWhen.swift:72
            _parent.dispose()
: Parent
0045        private let _errorHandlerSubscription
RetryWhen.swift:63
                _errorHandlerSubscription.disposable = errorHandlerSubscription
RetryWhen.swift:78
        _errorHandlerSubscription.dispose()
 = SingleAssignmentDisposable()
0046    
0047        init
RetryWhen.swift:122
        let iter = RetryWhenSequenceSinkIter(parent: self)
(parent: Parent) {
0048            _parent = parent
0049        }
0050    
0051        func on(event: Event<E>) {
0052            switch event {
0053            case .Next:
0054                _parent.forwardOn(event)
0055            case .Error(let error):
0056                _parent._lastError = error
0057    
0058                if let failedWith = error as? Error {
0059                    // dispose current subscription
0060                    super.dispose()
0061    
0062                    let errorHandlerSubscription = _parent._notifier.subscribe(RetryTriggerSink(parent: self))
0063                    _errorHandlerSubscription.disposable = errorHandlerSubscription
0064                    _parent._errorSubject.on(.Next(failedWith))
0065                }
0066                else {
0067                    _parent.forwardOn(.Error(error))
0068                    _parent.dispose()
0069                }
0070            case .Completed:
0071                _parent.forwardOn(event)
0072                _parent.dispose()
0073            }
0074        }
0075    
0076        override func dispose() {
0077            super.dispose()
0078            _errorHandlerSubscription.dispose()
0079        }
0080    }
0081    
0082    class RetryWhenSequenceSink
RetryWhen.swift:42
    typealias Parent = RetryWhenSequenceSink<S, O, TriggerObservable, Error>
RetryWhen.swift:146
        let sink = RetryWhenSequenceSink<S, O, TriggerObservable, Error>(parent: self, observer: observer)
<S
RetryWhen.swift:83
    : TailRecursiveSink<S, O> {
RetryWhen.swift:85
    typealias Parent = RetryWhenSequence<S, TriggerObservable, Error>
: SequenceType, O
RetryWhen.swift:83
    : TailRecursiveSink<S, O> {
RetryWhen.swift:84
    typealias Element = O.E
RetryWhen.swift:96
    init(parent: Parent, observer: O) {
: ObserverType, TriggerObservable
RetryWhen.swift:85
    typealias Parent = RetryWhenSequence<S, TriggerObservable, Error>
RetryWhen.swift:93
    private let _handler: Observable<TriggerObservable.E>
RetryWhen.swift:94
    private let _notifier = PublishSubject<TriggerObservable.E>()
: ObservableType, Error
RetryWhen.swift:85
    typealias Parent = RetryWhenSequence<S, TriggerObservable, Error>
RetryWhen.swift:92
    private let _errorSubject = PublishSubject<Error>()
 where S.Generator.Element : ObservableType, S.Generator.Element.E == O.E>
0083        : TailRecursiveSink<S, O> {
0084        typealias Element = O.E
0085        typealias Parent
RetryWhen.swift:89
    private let _parent: Parent
RetryWhen.swift:96
    init(parent: Parent, observer: O) {
 = RetryWhenSequence<S, TriggerObservable, Error>
0086        
0087        let _lock = NSRecursiveLock()
0088        
0089        private let _parent
RetryWhen.swift:97
        _parent = parent
: Parent
0090        
0091        private var _lastError
RetryWhen.swift:26
            _parent._parent._lastError = nil
RetryWhen.swift:56
            _parent._lastError = error
RetryWhen.swift:103
        if let lastError = _lastError {
RetryWhen.swift:105
            _lastError = nil
: ErrorType?
0092        private let _errorSubject
RetryWhen.swift:64
                _parent._errorSubject.on(.Next(failedWith))
RetryWhen.swift:98
        _handler = parent._notificationHandler(_errorSubject).asObservable()
 = PublishSubject<Error>()
0093        private let _handler
RetryWhen.swift:98
        _handler = parent._notificationHandler(_errorSubject).asObservable()
RetryWhen.swift:128
        let triggerSubscription = _handler.subscribe(_notifier.asObserver())
: Observable<TriggerObservable.E>
0094        private let _notifier
RetryWhen.swift:62
                let errorHandlerSubscription = _parent._notifier.subscribe(RetryTriggerSink(parent: self))
RetryWhen.swift:128
        let triggerSubscription = _handler.subscribe(_notifier.asObserver())
 = PublishSubject<TriggerObservable.E>()
0095    
0096        init(parent: Parent, observer: O) {
0097            _parent = parent
0098            _handler = parent._notificationHandler(_errorSubject).asObservable()
0099            super.init(observer: observer)
0100        }
0101        
0102        override func done() {
0103            if let lastError = _lastError {
0104                forwardOn(.Error(lastError))
0105                _lastError = nil
0106            }
0107            else {
0108                forwardOn(.Completed)
0109            }
0110    
0111            dispose()
0112        }
0113        
0114        override func extract(observable: Observable<E>) -> SequenceGenerator? {
0115            // It is important to always return `nil` here because there are sideffects in the `run` method
0116            // that are dependant on particular `retryWhen` operator so single operator stack can't be reused in this
0117            // case.
0118            return nil
0119        }
0120    
0121        override func subscribeToNext(source: Observable<E>) -> Disposable {
0122            let iter = RetryWhenSequenceSinkIter(parent: self)
0123            iter.disposable = source.subscribe(iter)
0124            return iter
0125        }
0126    
0127        override func run
RetryWhen.swift:147
        sink.disposable = sink.run((self._sources.generate(), nil))
(sources: SequenceGenerator) -> Disposable {
0128            let triggerSubscription = _handler.subscribe(_notifier.asObserver())
0129            let superSubscription = super.run(sources)
0130            return StableCompositeDisposable.create(superSubscription, triggerSubscription)
0131        }
0132    }
0133    
0134    class RetryWhenSequence
Observable+Single.swift:219
            return RetryWhenSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()), notificationHandler: notificationHandler)
Observable+Single.swift:234
            return RetryWhenSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()), notificationHandler: notificationHandler)
RetryWhen.swift:85
    typealias Parent = RetryWhenSequence<S, TriggerObservable, Error>
<S
RetryWhen.swift:134
class RetryWhenSequence<S: SequenceType, TriggerObservable: ObservableType, Error where S.Generator.Element : ObservableType> : Producer<S.Generator.Element.E> {
RetryWhen.swift:135
    typealias Element = S.Generator.Element.E
RetryWhen.swift:137
    private let _sources: S
RetryWhen.swift:140
    init(sources: S, notificationHandler: Observable<Error> -> TriggerObservable) {
RetryWhen.swift:146
        let sink = RetryWhenSequenceSink<S, O, TriggerObservable, Error>(parent: self, observer: observer)
: SequenceType, TriggerObservable
RetryWhen.swift:138
    private let _notificationHandler: Observable<Error> -> TriggerObservable
RetryWhen.swift:140
    init(sources: S, notificationHandler: Observable<Error> -> TriggerObservable) {
RetryWhen.swift:146
        let sink = RetryWhenSequenceSink<S, O, TriggerObservable, Error>(parent: self, observer: observer)
: ObservableType, Error
RetryWhen.swift:138
    private let _notificationHandler: Observable<Error> -> TriggerObservable
RetryWhen.swift:140
    init(sources: S, notificationHandler: Observable<Error> -> TriggerObservable) {
RetryWhen.swift:146
        let sink = RetryWhenSequenceSink<S, O, TriggerObservable, Error>(parent: self, observer: observer)
 where S.Generator.Element : ObservableType> : Producer<S.Generator.Element.E> {
0135        typealias Element
RetryWhen.swift:145
    override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
 = S.Generator.Element.E
0136        
0137        private let _sources
RetryWhen.swift:141
        _sources = sources
RetryWhen.swift:147
        sink.disposable = sink.run((self._sources.generate(), nil))
: S
0138        private let _notificationHandler
RetryWhen.swift:98
        _handler = parent._notificationHandler(_errorSubject).asObservable()
RetryWhen.swift:142
        _notificationHandler = notificationHandler
: Observable<Error> -> TriggerObservable
0139        
0140        init
Observable+Single.swift:219
            return RetryWhenSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()), notificationHandler: notificationHandler)
Observable+Single.swift:234
            return RetryWhenSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()), notificationHandler: notificationHandler)
(sources: S, notificationHandler: Observable<Error> -> TriggerObservable) {
0141            _sources = sources
0142            _notificationHandler = notificationHandler
0143        }
0144        
0145        override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
0146            let sink = RetryWhenSequenceSink<S, O, TriggerObservable, Error>(parent: self, observer: observer)
0147            sink.disposable = sink.run((self._sources.generate(), nil))
0148            return sink
0149        }
0150    }