0001    //
0002    //  Skip.swift
0003    //  RxSwift
0004    //
0005    //  Created by Krunoslav Zaher on 6/25/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    // count version
0012    
0013    class SkipCountSink
Skip.swift:58
        let sink = SkipCountSink(parent: self, observer: observer)
<ElementType
Skip.swift:14
    typealias Parent = SkipCount<ElementType>
Skip.swift:15
    typealias Element = ElementType
, O
Skip.swift:13
class SkipCountSink<ElementType, O: ObserverType where O.E == ElementType> : Sink<O>, ObserverType {
Skip.swift:21
    init(parent: Parent, observer: O) {
: ObserverType where O.E == ElementType> : Sink<O>, ObserverType {
0014        typealias Parent
Skip.swift:17
    let parent: Parent
Skip.swift:21
    init(parent: Parent, observer: O) {
 = SkipCount<ElementType>
0015        typealias Element
Skip.swift:27
    func on(event: Event<Element>) {
 = ElementType
0016        
0017        let parent
Skip.swift:22
        self.parent = parent
: Parent
0018        
0019        var remaining
Skip.swift:23
        self.remaining = parent.count
Skip.swift:31
            if remaining <= 0 {
Skip.swift:35
                remaining -= 1
: Int
0020        
0021        init
Skip.swift:58
        let sink = SkipCountSink(parent: self, observer: observer)
(parent: Parent, observer: O) {
0022            self.parent = parent
0023            self.remaining = parent.count
0024            super.init(observer: observer)
0025        }
0026        
0027        func on(event: Event<Element>) {
0028            switch event {
0029            case .Next(let value):
0030                
0031                if remaining <= 0 {
0032                    forwardOn(.Next(value))
0033                }
0034                else {
0035                    remaining -= 1
0036                }
0037            case .Error:
0038                forwardOn(event)
0039                self.dispose()
0040            case .Completed:
0041                forwardOn(event)
0042                self.dispose()
0043            }
0044        }
0045        
0046    }
0047    
0048    class SkipCount
Observable+StandardSequenceOperators.swift:126
        return SkipCount(source: asObservable(), count: count)
Skip.swift:14
    typealias Parent = SkipCount<ElementType>
<Element
Skip.swift:48
class SkipCount<Element>: Producer<Element> {
Skip.swift:49
    let source: Observable<Element>
Skip.swift:52
    init(source: Observable<Element>, count: Int) {
Skip.swift:57
    override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
>: Producer<Element> {
0049        let source
Skip.swift:53
        self.source = source
Skip.swift:59
        sink.disposable = source.subscribe(sink)
: Observable<Element>
0050        let count
Skip.swift:23
        self.remaining = parent.count
Skip.swift:54
        self.count = count
: Int
0051        
0052        init
Observable+StandardSequenceOperators.swift:126
        return SkipCount(source: asObservable(), count: count)
(source: Observable<Element>, count: Int) {
0053            self.source = source
0054            self.count = count
0055        }
0056        
0057        override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
0058            let sink = SkipCountSink(parent: self, observer: observer)
0059            sink.disposable = source.subscribe(sink)
0060    
0061            return sink
0062        }
0063    }
0064    
0065    // time version
0066    
0067    class SkipTimeSink
Skip.swift:124
        let sink = SkipTimeSink(parent: self, observer: observer)
<ElementType
Skip.swift:68
    typealias Parent = SkipTime<ElementType>
Skip.swift:69
    typealias Element = ElementType
, O
Skip.swift:67
class SkipTimeSink<ElementType, O: ObserverType where O.E == ElementType> : Sink<O>, ObserverType {
Skip.swift:76
    init(parent: Parent, observer: O) {
: ObserverType where O.E == ElementType> : Sink<O>, ObserverType {
0068        typealias Parent
Skip.swift:71
    let parent: Parent
Skip.swift:76
    init(parent: Parent, observer: O) {
 = SkipTime<ElementType>
0069        typealias Element
Skip.swift:81
    func on(event: Event<Element>) {
 = ElementType
0070    
0071        let parent
Skip.swift:77
        self.parent = parent
Skip.swift:101
        let disposeTimer = parent.scheduler.scheduleRelative((), dueTime: self.parent.duration) {
Skip.swift:101
        let disposeTimer = parent.scheduler.scheduleRelative((), dueTime: self.parent.duration) {
Skip.swift:106
        let disposeSubscription = parent.source.subscribe(self)
: Parent
0072        
0073        // state
0074        var open
Skip.swift:84
            if open {
Skip.swift:97
        open = true
 = false
0075        
0076        init
Skip.swift:124
        let sink = SkipTimeSink(parent: self, observer: observer)
(parent: Parent, observer: O) {
0077            self.parent = parent
0078            super.init(observer: observer)
0079        }
0080        
0081        func on(event: Event<Element>) {
0082            switch event {
0083            case .Next(let value):
0084                if open {
0085                    forwardOn(.Next(value))
0086                }
0087            case .Error:
0088                forwardOn(event)
0089                self.dispose()
0090            case .Completed:
0091                forwardOn(event)
0092                self.dispose()
0093            }
0094        }
0095        
0096        func tick
Skip.swift:102
            self.tick()
() {
0097            open = true
0098        }
0099        
0100        func run
Skip.swift:125
        sink.disposable = sink.run()
() -> Disposable {
0101            let disposeTimer = parent.scheduler.scheduleRelative((), dueTime: self.parent.duration) {
0102                self.tick()
0103                return NopDisposable.instance
0104            }
0105            
0106            let disposeSubscription = parent.source.subscribe(self)
0107            
0108            return BinaryDisposable(disposeTimer, disposeSubscription)
0109        }
0110    }
0111    
0112    class SkipTime
Observable+Time.swift:152
        return SkipTime(source: self.asObservable(), duration: duration, scheduler: scheduler)
Skip.swift:68
    typealias Parent = SkipTime<ElementType>
<Element
Skip.swift:112
class SkipTime<Element>: Producer<Element> {
Skip.swift:113
    let source: Observable<Element>
Skip.swift:117
    init(source: Observable<Element>, duration: RxTimeInterval, scheduler: SchedulerType) {
Skip.swift:123
    override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
>: Producer<Element> {
0113        let source
Skip.swift:106
        let disposeSubscription = parent.source.subscribe(self)
Skip.swift:118
        self.source = source
: Observable<Element>
0114        let duration
Skip.swift:101
        let disposeTimer = parent.scheduler.scheduleRelative((), dueTime: self.parent.duration) {
Skip.swift:120
        self.duration = duration
: RxTimeInterval
0115        let scheduler
Skip.swift:101
        let disposeTimer = parent.scheduler.scheduleRelative((), dueTime: self.parent.duration) {
Skip.swift:119
        self.scheduler = scheduler
: SchedulerType
0116        
0117        init
Observable+Time.swift:152
        return SkipTime(source: self.asObservable(), duration: duration, scheduler: scheduler)
(source: Observable<Element>, duration: RxTimeInterval, scheduler: SchedulerType) {
0118            self.source = source
0119            self.scheduler = scheduler
0120            self.duration = duration
0121        }
0122        
0123        override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
0124            let sink = SkipTimeSink(parent: self, observer: observer)
0125            sink.disposable = sink.run()
0126            return sink
0127        }
0128    }