0001    //
0002    //  SkipWhile.swift
0003    //  Rx
0004    //
0005    //  Created by Yury Korolev on 10/9/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    class SkipWhileSink
SkipWhile.swift:105
            let sink = SkipWhileSink(parent: self, observer: observer)
<ElementType
SkipWhile.swift:11
    typealias Parent = SkipWhile<ElementType>
SkipWhile.swift:12
    typealias Element = ElementType
, O
SkipWhile.swift:9
class SkipWhileSink<ElementType, O: ObserverType where O.E == ElementType> : Sink<O>, ObserverType {
SkipWhile.swift:17
    init(parent: Parent, observer: O) {
: ObserverType where O.E == ElementType> : Sink<O>, ObserverType {
0010    
0011        typealias Parent
SkipWhile.swift:14
    private let _parent: Parent
SkipWhile.swift:17
    init(parent: Parent, observer: O) {
 = SkipWhile<ElementType>
0012        typealias Element
SkipWhile.swift:22
    func on(event: Event<Element>) {
 = ElementType
0013    
0014        private let _parent
SkipWhile.swift:18
        _parent = parent
SkipWhile.swift:27
                    _running = try !_parent._predicate(value)
: Parent
0015        private var _running
SkipWhile.swift:25
            if !_running {
SkipWhile.swift:27
                    _running = try !_parent._predicate(value)
SkipWhile.swift:35
            if _running {
 = false
0016    
0017        init
SkipWhile.swift:105
            let sink = SkipWhileSink(parent: self, observer: observer)
(parent: Parent, observer: O) {
0018            _parent = parent
0019            super.init(observer: observer)
0020        }
0021    
0022        func on(event: Event<Element>) {
0023            switch event {
0024            case .Next(let value):
0025                if !_running {
0026                    do {
0027                        _running = try !_parent._predicate(value)
0028                    } catch let e {
0029                        forwardOn(.Error(e))
0030                        dispose()
0031                        return
0032                    }
0033                }
0034    
0035                if _running {
0036                    forwardOn(.Next(value))
0037                }
0038            case .Error, .Completed:
0039                forwardOn(event)
0040                dispose()
0041            }
0042        }
0043    }
0044    
0045    class SkipWhileSinkWithIndex
SkipWhile.swift:110
            let sink = SkipWhileSinkWithIndex(parent: self, observer: observer)
<ElementType
SkipWhile.swift:47
    typealias Parent = SkipWhile<ElementType>
SkipWhile.swift:48
    typealias Element = ElementType
, O
SkipWhile.swift:45
class SkipWhileSinkWithIndex<ElementType, O: ObserverType where O.E == ElementType> : Sink<O>, ObserverType {
SkipWhile.swift:54
    init(parent: Parent, observer: O) {
: ObserverType where O.E == ElementType> : Sink<O>, ObserverType {
0046    
0047        typealias Parent
SkipWhile.swift:50
    private let _parent: Parent
SkipWhile.swift:54
    init(parent: Parent, observer: O) {
 = SkipWhile<ElementType>
0048        typealias Element
SkipWhile.swift:59
    func on(event: Event<Element>) {
 = ElementType
0049    
0050        private let _parent
SkipWhile.swift:55
        _parent = parent
SkipWhile.swift:64
                    _running = try !_parent._predicateWithIndex(value, _index)
: Parent
0051        private var _index
SkipWhile.swift:64
                    _running = try !_parent._predicateWithIndex(value, _index)
SkipWhile.swift:65
                    try incrementChecked(&_index)
 = 0
0052        private var _running
SkipWhile.swift:62
            if !_running {
SkipWhile.swift:64
                    _running = try !_parent._predicateWithIndex(value, _index)
SkipWhile.swift:73
            if _running {
 = false
0053    
0054        init
SkipWhile.swift:110
            let sink = SkipWhileSinkWithIndex(parent: self, observer: observer)
(parent: Parent, observer: O) {
0055            _parent = parent
0056            super.init(observer: observer)
0057        }
0058    
0059        func on(event: Event<Element>) {
0060            switch event {
0061            case .Next(let value):
0062                if !_running {
0063                    do {
0064                        _running = try !_parent._predicateWithIndex(value, _index)
0065                        try incrementChecked(&_index)
0066                    } catch let e {
0067                        forwardOn(.Error(e))
0068                        dispose()
0069                        return
0070                    }
0071                }
0072    
0073                if _running {
0074                    forwardOn(.Next(value))
0075                }
0076            case .Error, .Completed:
0077                forwardOn(event)
0078                dispose()
0079            }
0080        }
0081    }
0082    
0083    class SkipWhile
Observable+StandardSequenceOperators.swift:144
        return SkipWhile(source: asObservable(), predicate: predicate)
Observable+StandardSequenceOperators.swift:158
        return SkipWhile(source: asObservable(), predicate: predicate)
SkipWhile.swift:11
    typealias Parent = SkipWhile<ElementType>
SkipWhile.swift:47
    typealias Parent = SkipWhile<ElementType>
<Element
SkipWhile.swift:83
class SkipWhile<Element>: Producer<Element> {
SkipWhile.swift:84
    typealias Predicate = (Element) throws -> Bool
SkipWhile.swift:85
    typealias PredicateWithIndex = (Element, Int) throws -> Bool
SkipWhile.swift:87
    private let _source: Observable<Element>
SkipWhile.swift:91
    init(source: Observable<Element>, predicate: Predicate) {
SkipWhile.swift:97
    init(source: Observable<Element>, predicate: PredicateWithIndex) {
SkipWhile.swift:103
    override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
>: Producer<Element> {
0084        typealias Predicate
SkipWhile.swift:88
    private let _predicate: Predicate!
SkipWhile.swift:91
    init(source: Observable<Element>, predicate: Predicate) {
 = (Element) throws -> Bool
0085        typealias PredicateWithIndex
SkipWhile.swift:89
    private let _predicateWithIndex: PredicateWithIndex!
SkipWhile.swift:97
    init(source: Observable<Element>, predicate: PredicateWithIndex) {
 = (Element, Int) throws -> Bool
0086    
0087        private let _source
SkipWhile.swift:92
        _source = source
SkipWhile.swift:98
        _source = source
SkipWhile.swift:106
            sink.disposable = _source.subscribe(sink)
SkipWhile.swift:111
            sink.disposable = _source.subscribe(sink)
: Observable<Element>
0088        private let _predicate
SkipWhile.swift:27
                    _running = try !_parent._predicate(value)
SkipWhile.swift:93
        _predicate = predicate
SkipWhile.swift:99
        _predicate = nil
SkipWhile.swift:104
        if let _ = _predicate {
: Predicate!
0089        private let _predicateWithIndex
SkipWhile.swift:64
                    _running = try !_parent._predicateWithIndex(value, _index)
SkipWhile.swift:94
        _predicateWithIndex = nil
SkipWhile.swift:100
        _predicateWithIndex = predicate
: PredicateWithIndex!
0090    
0091        init
Observable+StandardSequenceOperators.swift:144
        return SkipWhile(source: asObservable(), predicate: predicate)
(source: Observable<Element>, predicate: Predicate) {
0092            _source = source
0093            _predicate = predicate
0094            _predicateWithIndex = nil
0095        }
0096    
0097        init
Observable+StandardSequenceOperators.swift:158
        return SkipWhile(source: asObservable(), predicate: predicate)
(source: Observable<Element>, predicate: PredicateWithIndex) {
0098            _source = source
0099            _predicate = nil
0100            _predicateWithIndex = predicate
0101        }
0102    
0103        override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
0104            if let _ = _predicate {
0105                let sink = SkipWhileSink(parent: self, observer: observer)
0106                sink.disposable = _source.subscribe(sink)
0107                return sink
0108            }
0109            else {
0110                let sink = SkipWhileSinkWithIndex(parent: self, observer: observer)
0111                sink.disposable = _source.subscribe(sink)
0112                return sink
0113            }
0114        }
0115    }
0116