0001    //
0002    //  Catch.swift
0003    //  RxSwift
0004    //
0005    //  Created by Krunoslav Zaher on 4/19/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    // catch with callback
0012    
0013    class CatchSinkProxy
Catch.swift:66
                let observer = CatchSinkProxy(parent: self)
<O
Catch.swift:14
    typealias E = O.E
Catch.swift:15
    typealias Parent = CatchSink<O>
: ObserverType> : ObserverType {
0014        typealias E
Catch.swift:23
    func on(event: Event<E>) {
 = O.E
0015        typealias Parent
Catch.swift:17
    private let _parent: Parent
Catch.swift:19
    init(parent: Parent) {
 = CatchSink<O>
0016        
0017        private let _parent
Catch.swift:20
        _parent = parent
Catch.swift:24
        _parent.forwardOn(event)
Catch.swift:30
            _parent.dispose()
: Parent
0018        
0019        init
Catch.swift:66
                let observer = CatchSinkProxy(parent: self)
(parent: Parent) {
0020            _parent = parent
0021        }
0022        
0023        func on(event: Event<E>) {
0024            _parent.forwardOn(event)
0025            
0026            switch event {
0027            case .Next:
0028                break
0029            case .Error, .Completed:
0030                _parent.dispose()
0031            }
0032        }
0033    }
0034    
0035    class CatchSink
Catch.swift:15
    typealias Parent = CatchSink<O>
Catch.swift:90
        let sink = CatchSink(parent: self, observer: observer)
<O
Catch.swift:35
class CatchSink<O: ObserverType> : Sink<O>, ObserverType {
Catch.swift:36
    typealias E = O.E
Catch.swift:42
    init(parent: Parent, observer: O) {
: ObserverType> : Sink<O>, ObserverType {
0036        typealias E
Catch.swift:37
    typealias Parent = Catch<E>
Catch.swift:55
    func on(event: Event<E>) {
 = O.E
0037        typealias Parent
Catch.swift:39
    private let _parent: Parent
Catch.swift:42
    init(parent: Parent, observer: O) {
 = Catch<E>
0038        
0039        private let _parent
Catch.swift:43
        _parent = parent
Catch.swift:50
        d1.disposable = _parent._source.subscribe(self)
Catch.swift:64
                let catchSequence = try _parent._handler(error)
: Parent
0040        private let _subscription
Catch.swift:49
        _subscription.disposable = d1
Catch.swift:52
        return _subscription
Catch.swift:68
                _subscription.disposable = catchSequence.subscribe(observer)
 = SerialDisposable()
0041        
0042        init
Catch.swift:90
        let sink = CatchSink(parent: self, observer: observer)
(parent: Parent, observer: O) {
0043            _parent = parent
0044            super.init(observer: observer)
0045        }
0046        
0047        func run
Catch.swift:91
        sink.disposable = sink.run()
() -> Disposable {
0048            let d1 = SingleAssignmentDisposable()
0049            _subscription.disposable = d1
0050            d1.disposable = _parent._source.subscribe(self)
0051    
0052            return _subscription
0053        }
0054        
0055        func on(event: Event<E>) {
0056            switch event {
0057            case .Next:
0058                forwardOn(event)
0059            case .Completed:
0060                forwardOn(event)
0061                dispose()
0062            case .Error(let error):
0063                do {
0064                    let catchSequence = try _parent._handler(error)
0065    
0066                    let observer = CatchSinkProxy(parent: self)
0067                    
0068                    _subscription.disposable = catchSequence.subscribe(observer)
0069                }
0070                catch let e {
0071                    forwardOn(.Error(e))
0072                    dispose()
0073                }
0074            }
0075        }
0076    }
0077    
0078    class Catch
Catch.swift:37
    typealias Parent = Catch<E>
Observable+Multiple.swift:192
        return Catch(source: asObservable(), handler: handler)
Observable+Multiple.swift:206
        return Catch(source: asObservable(), handler: { _ in Observable.just(element) })
<Element
Catch.swift:78
class Catch<Element> : Producer<Element> {
Catch.swift:79
    typealias Handler = (ErrorType) throws -> Observable<Element>
Catch.swift:81
    private let _source: Observable<Element>
Catch.swift:84
    init(source: Observable<Element>, handler: Handler) {
Catch.swift:89
    override func run<O: ObserverType where O.E == Element>(observer: O) -> Disposable {
> : Producer<Element> {
0079        typealias Handler
Catch.swift:82
    private let _handler: Handler
Catch.swift:84
    init(source: Observable<Element>, handler: Handler) {
 = (ErrorType) throws -> Observable<Element>
0080        
0081        private let _source
Catch.swift:50
        d1.disposable = _parent._source.subscribe(self)
Catch.swift:85
        _source = source
: Observable<Element>
0082        private let _handler
Catch.swift:64
                let catchSequence = try _parent._handler(error)
Catch.swift:86
        _handler = handler
: Handler
0083        
0084        init
Observable+Multiple.swift:192
        return Catch(source: asObservable(), handler: handler)
Observable+Multiple.swift:206
        return Catch(source: asObservable(), handler: { _ in Observable.just(element) })
(source: Observable<Element>, handler: Handler) {
0085            _source = source
0086            _handler = handler
0087        }
0088        
0089        override func run<O: ObserverType where O.E == Element>(observer: O) -> Disposable {
0090            let sink = CatchSink(parent: self, observer: observer)
0091            sink.disposable = sink.run()
0092            return sink
0093        }
0094    }
0095    
0096    // catch enumerable
0097    
0098    class CatchSequenceSink
Catch.swift:158
        let sink = CatchSequenceSink<S, O>(observer: observer)
<S
Catch.swift:99
    : TailRecursiveSink<S, O>
Catch.swift:102
    typealias Parent = CatchSequence<S>
Catch.swift:139
        if let onError = observable as? CatchSequence<S> {
: SequenceType, O
Catch.swift:99
    : TailRecursiveSink<S, O>
Catch.swift:101
    typealias Element = O.E
Catch.swift:106
    override init(observer: O) {
: ObserverType where S.Generator.Element : ObservableConvertibleType, S.Generator.Element.E == O.E>
0099        : TailRecursiveSink<S, O>
0100        , ObserverType {
0101        typealias Element
Catch.swift:110
    func on(event: Event<Element>) {
Catch.swift:138
    override func extract(observable: Observable<Element>) -> SequenceGenerator? {
 = O.E
0102        typealias Parent = CatchSequence<S>
0103        
0104        private var _lastError
Catch.swift:115
            _lastError = error
Catch.swift:128
        if let lastError = _lastError {
: ErrorType?
0105        
0106        override init(observer: O) {
0107            super.init(observer: observer)
0108        }
0109        
0110        func on(event: Event<Element>) {
0111            switch event {
0112            case .Next:
0113                forwardOn(event)
0114            case .Error(let error):
0115                _lastError = error
0116                schedule(.MoveNext)
0117            case .Completed:
0118                forwardOn(event)
0119                dispose()
0120            }
0121        }
0122    
0123        override func subscribeToNext(source: Observable<E>) -> Disposable {
0124            return source.subscribe(self)
0125        }
0126        
0127        override func done() {
0128            if let lastError = _lastError {
0129                forwardOn(.Error(lastError))
0130            }
0131            else {
0132                forwardOn(.Completed)
0133            }
0134            
0135            self.dispose()
0136        }
0137        
0138        override func extract(observable: Observable<Element>) -> SequenceGenerator? {
0139            if let onError = observable as? CatchSequence<S> {
0140                return (onError.sources.generate(), nil)
0141            }
0142            else {
0143                return nil
0144            }
0145        }
0146    }
0147    
0148    class CatchSequence
Catch.swift:102
    typealias Parent = CatchSequence<S>
Catch.swift:139
        if let onError = observable as? CatchSequence<S> {
Observable+Multiple.swift:222
        return CatchSequence(sources: self)
Observable+Single.swift:188
        return CatchSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()))
Observable+Single.swift:204
        return CatchSequence(sources: Repeat(count: maxAttemptCount, repeatedValue: self.asObservable()))
<S
Catch.swift:148
class CatchSequence<S: SequenceType where S.Generator.Element : ObservableConvertibleType> : Producer<S.Generator.Element.E> {
Catch.swift:149
    typealias Element = S.Generator.Element.E
Catch.swift:151
    let sources: S
Catch.swift:153
    init(sources: S) {
Catch.swift:158
        let sink = CatchSequenceSink<S, O>(observer: observer)
: SequenceType where S.Generator.Element : ObservableConvertibleType> : Producer<S.Generator.Element.E> {
0149        typealias Element
Catch.swift:157
    override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
 = S.Generator.Element.E
0150        
0151        let sources
Catch.swift:140
            return (onError.sources.generate(), nil)
Catch.swift:154
        self.sources = sources
Catch.swift:159
        sink.disposable = sink.run((self.sources.generate(), nil))
: S
0152        
0153        init
Observable+Multiple.swift:222
        return CatchSequence(sources: self)
Observable+Single.swift:188
        return CatchSequence(sources: InfiniteSequence(repeatedValue: self.asObservable()))
Observable+Single.swift:204
        return CatchSequence(sources: Repeat(count: maxAttemptCount, repeatedValue: self.asObservable()))
(sources: S) {
0154            self.sources = sources
0155        }
0156        
0157        override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
0158            let sink = CatchSequenceSink<S, O>(observer: observer)
0159            sink.disposable = sink.run((self.sources.generate(), nil))
0160            return sink
0161        }
0162    }