0001    //
0002    //  TakeWhile.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 TakeWhileSink
TakeWhile.swift:123
            let sink = TakeWhileSink(parent: self, observer: observer)<ElementType
TakeWhile.swift:14
    typealias Parent = TakeWhile<ElementType>
TakeWhile.swift:15
    typealias Element = ElementType, O
TakeWhile.swift:12
    : Sink<O>
TakeWhile.swift:21
    init(parent: Parent, observer: O) {: ObserverType where O.E == ElementType>
0012        : Sink<O>
0013        , ObserverType {
0014        typealias Parent
TakeWhile.swift:17
    private let _parent: Parent
TakeWhile.swift:21
    init(parent: Parent, observer: O) { = TakeWhile<ElementType>
0015        typealias Element
TakeWhile.swift:26
    func on(event: Event<Element>) { = ElementType
0016    
0017        private let _parent
TakeWhile.swift:22
        _parent = parent
TakeWhile.swift:34
                _running = try _parent._predicate(value): Parent
0018    
0019        private var _running
TakeWhile.swift:29
            if !_running {
TakeWhile.swift:34
                _running = try _parent._predicate(value)
TakeWhile.swift:41
            if _running { = true
0020    
0021        init
TakeWhile.swift:123
            let sink = TakeWhileSink(parent: self, observer: observer)(parent: Parent, observer: O) {
0022            _parent = parent
0023            super.init(observer: observer)
0024        }
0025        
0026        func on(event: Event<Element>) {
0027            switch event {
0028            case .Next(let value):
0029                if !_running {
0030                    return
0031                }
0032                
0033                do {
0034                    _running = try _parent._predicate(value)
0035                } catch let e {
0036                    forwardOn(.Error(e))
0037                    dispose()
0038                    return
0039                }
0040                
0041                if _running {
0042                    forwardOn(.Next(value))
0043                } else {
0044                    forwardOn(.Completed)
0045                    dispose()
0046                }
0047            case .Error, .Completed:
0048                forwardOn(event)
0049                dispose()
0050            }
0051        }
0052        
0053    }
0054    
0055    class TakeWhileSinkWithIndex
TakeWhile.swift:127
            let sink = TakeWhileSinkWithIndex(parent: self, observer: observer)<ElementType
TakeWhile.swift:58
    typealias Parent = TakeWhile<ElementType>
TakeWhile.swift:59
    typealias Element = ElementType, O
TakeWhile.swift:56
    : Sink<O>
TakeWhile.swift:66
    init(parent: Parent, observer: O) {: ObserverType where O.E == ElementType>
0056        : Sink<O>
0057        , ObserverType {
0058        typealias Parent
TakeWhile.swift:61
    private let _parent: Parent
TakeWhile.swift:66
    init(parent: Parent, observer: O) { = TakeWhile<ElementType>
0059        typealias Element
TakeWhile.swift:71
    func on(event: Event<Element>) { = ElementType
0060        
0061        private let _parent
TakeWhile.swift:67
        _parent = parent
TakeWhile.swift:79
                _running = try _parent._predicateWithIndex(value, _index): Parent
0062        
0063        private var _running
TakeWhile.swift:74
            if !_running {
TakeWhile.swift:79
                _running = try _parent._predicateWithIndex(value, _index)
TakeWhile.swift:87
            if _running { = true
0064        private var _index
TakeWhile.swift:79
                _running = try _parent._predicateWithIndex(value, _index)
TakeWhile.swift:80
                try incrementChecked(&_index) = 
0065        
0066        init
TakeWhile.swift:127
            let sink = TakeWhileSinkWithIndex(parent: self, observer: observer)(parent: Parent, observer: O) {
0067            _parent = parent
0068            super.init(observer: observer)
0069        }
0070        
0071        func on(event: Event<Element>) {
0072            switch event {
0073            case .Next(let value):
0074                if !_running {
0075                    return
0076                }
0077                
0078                do {
0079                    _running = try _parent._predicateWithIndex(value, _index)
0080                    try incrementChecked(&_index)
0081                } catch let e {
0082                    forwardOn(.Error(e))
0083                    dispose()
0084                    return
0085                }
0086                
0087                if _running {
0088                    forwardOn(.Next(value))
0089                } else {
0090                    forwardOn(.Completed)
0091                    dispose()
0092                }
0093            case .Error, .Completed:
0094                forwardOn(event)
0095                dispose()
0096            }
0097        }
0098        
0099    }
0100    
0101    class TakeWhile
Observable+StandardSequenceOperators.swift:45
        return TakeWhile(source: asObservable(), predicate: predicate)
Observable+StandardSequenceOperators.swift:61
        return TakeWhile(source: asObservable(), predicate: predicate)
TakeWhile.swift:14
    typealias Parent = TakeWhile<ElementType>
TakeWhile.swift:58
    typealias Parent = TakeWhile<ElementType><Element
TakeWhile.swift:101
class TakeWhile<Element>: Producer<Element> {
TakeWhile.swift:102
    typealias Predicate = (Element) throws -> Bool
TakeWhile.swift:103
    typealias PredicateWithIndex = (Element, Int) throws -> Bool
TakeWhile.swift:105
    private let _source: Observable<Element>
TakeWhile.swift:109
    init(source: Observable<Element>, predicate: Predicate) {
TakeWhile.swift:115
    init(source: Observable<Element>, predicate: PredicateWithIndex) {
TakeWhile.swift:121
    override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {>: Producer<Element> {
0102        typealias Predicate
TakeWhile.swift:106
    private let _predicate: Predicate!
TakeWhile.swift:109
    init(source: Observable<Element>, predicate: Predicate) { = (Element) throws -> Bool
0103        typealias PredicateWithIndex
TakeWhile.swift:107
    private let _predicateWithIndex: PredicateWithIndex!
TakeWhile.swift:115
    init(source: Observable<Element>, predicate: PredicateWithIndex) { = (Element, Int) throws -> Bool
0104    
0105        private let _source
TakeWhile.swift:110
        _source = source
TakeWhile.swift:116
        _source = source
TakeWhile.swift:124
            sink.disposable = _source.subscribe(sink)
TakeWhile.swift:128
            sink.disposable = _source.subscribe(sink): Observable<Element>
0106        private let _predicate
TakeWhile.swift:34
                _running = try _parent._predicate(value)
TakeWhile.swift:111
        _predicate = predicate
TakeWhile.swift:117
        _predicate = nil
TakeWhile.swift:122
        if let _ = _predicate {: Predicate!
0107        private let _predicateWithIndex
TakeWhile.swift:79
                _running = try _parent._predicateWithIndex(value, _index)
TakeWhile.swift:112
        _predicateWithIndex = nil
TakeWhile.swift:118
        _predicateWithIndex = predicate: PredicateWithIndex!
0108    
0109        init
Observable+StandardSequenceOperators.swift:45
        return TakeWhile(source: asObservable(), predicate: predicate)(source: Observable<Element>, predicate: Predicate) {
0110            _source = source
0111            _predicate = predicate
0112            _predicateWithIndex = nil
0113        }
0114        
0115        init
Observable+StandardSequenceOperators.swift:61
        return TakeWhile(source: asObservable(), predicate: predicate)(source: Observable<Element>, predicate: PredicateWithIndex) {
0116            _source = source
0117            _predicate = nil
0118            _predicateWithIndex = predicate
0119        }
0120        
0121        override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
0122            if let _ = _predicate {
0123                let sink = TakeWhileSink(parent: self, observer: observer)
0124                sink.disposable = _source.subscribe(sink)
0125                return sink
0126            } else {
0127                let sink = TakeWhileSinkWithIndex(parent: self, observer: observer)
0128                sink.disposable = _source.subscribe(sink)
0129                return sink
0130            }
0131        }
0132    }