0001    //
0002    //  Sample.swift
0003    //  RxSwift
0004    //
0005    //  Created by Krunoslav Zaher on 5/1/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    class SamplerSink
Sample.swift:89
        let samplerSubscription = _parent._sampler.subscribe(SamplerSink(parent: self))
<O
Sample.swift:17
    typealias Parent = SampleSequenceSink<O, SampleType>
: ObserverType, ElementType, SampleType
Sample.swift:15
    typealias E = SampleType
Sample.swift:17
    typealias Parent = SampleSequenceSink<O, SampleType>
 where O.E == ElementType>
0012        : ObserverType
0013        , LockOwnerType
0014        , SynchronizedOnType {
0015        typealias E
Sample.swift:29
    func on(event: Event<E>) {
Sample.swift:33
    func _synchronized_on(event: Event<E>) {
 = SampleType
0016        
0017        typealias Parent
Sample.swift:19
    private let _parent: Parent
Sample.swift:25
    init(parent: Parent) {
 = SampleSequenceSink<O, SampleType>
0018        
0019        private let _parent
Sample.swift:22
        return _parent._lock
Sample.swift:26
        _parent = parent
Sample.swift:36
            if let element = _parent._element {
Sample.swift:37
                if _parent._parent._onlyNew {
Sample.swift:38
                    _parent._element = nil
Sample.swift:41
                _parent.forwardOn(.Next(element))
Sample.swift:44
            if _parent._atEnd {
Sample.swift:45
                _parent.forwardOn(.Completed)
Sample.swift:46
                _parent.dispose()
Sample.swift:49
            _parent.forwardOn(.Error(e))
Sample.swift:50
            _parent.dispose()
Sample.swift:52
            if let element = _parent._element {
Sample.swift:53
                _parent._element = nil
Sample.swift:54
                _parent.forwardOn(.Next(element))
Sample.swift:56
            if _parent._atEnd {
Sample.swift:57
                _parent.forwardOn(.Completed)
Sample.swift:58
                _parent.dispose()
: Parent
0020    
0021        var _lock: NSRecursiveLock {
0022            return _parent._lock
0023        }
0024        
0025        init
Sample.swift:89
        let samplerSubscription = _parent._sampler.subscribe(SamplerSink(parent: self))
(parent: Parent) {
0026            _parent = parent
0027        }
0028        
0029        func on(event: Event<E>) {
0030            synchronizedOn(event)
0031        }
0032    
0033        func _synchronized_on(event: Event<E>) {
0034            switch event {
0035            case .Next:
0036                if let element = _parent._element {
0037                    if _parent._parent._onlyNew {
0038                        _parent._element = nil
0039                    }
0040                    
0041                    _parent.forwardOn(.Next(element))
0042                }
0043    
0044                if _parent._atEnd {
0045                    _parent.forwardOn(.Completed)
0046                    _parent.dispose()
0047                }
0048            case .Error(let e):
0049                _parent.forwardOn(.Error(e))
0050                _parent.dispose()
0051            case .Completed:
0052                if let element = _parent._element {
0053                    _parent._element = nil
0054                    _parent.forwardOn(.Next(element))
0055                }
0056                if _parent._atEnd {
0057                    _parent.forwardOn(.Completed)
0058                    _parent.dispose()
0059                }
0060            }
0061        }
0062    }
0063    
0064    class SampleSequenceSink
Sample.swift:17
    typealias Parent = SampleSequenceSink<O, SampleType>
Sample.swift:125
        let sink = SampleSequenceSink(parent: self, observer: observer)
<O
Sample.swift:65
    : Sink<O>
Sample.swift:69
    typealias Element = O.E
Sample.swift:82
    init(parent: Parent, observer: O) {
: ObserverType, SampleType
Sample.swift:70
    typealias Parent = Sample<Element, SampleType>
>
0065        : Sink<O>
0066        , ObserverType
0067        , LockOwnerType
0068        , SynchronizedOnType {
0069        typealias Element
Sample.swift:70
    typealias Parent = Sample<Element, SampleType>
Sample.swift:77
    private var _element = nil as Element?
Sample.swift:94
    func on(event: Event<Element>) {
Sample.swift:98
    func _synchronized_on(event: Event<Element>) {
 = O.E
0070        typealias Parent
Sample.swift:72
    private let _parent: Parent
Sample.swift:82
    init(parent: Parent, observer: O) {
 = Sample<Element, SampleType>
0071        
0072        private let _parent
Sample.swift:37
                if _parent._parent._onlyNew {
Sample.swift:83
        _parent = parent
Sample.swift:88
        _sourceSubscription.disposable = _parent._source.subscribe(self)
Sample.swift:89
        let samplerSubscription = _parent._sampler.subscribe(SamplerSink(parent: self))
: Parent
0073    
0074        let _lock
Sample.swift:22
        return _parent._lock
 = NSRecursiveLock()
0075        
0076        // state
0077        private var _element
Sample.swift:36
            if let element = _parent._element {
Sample.swift:38
                    _parent._element = nil
Sample.swift:52
            if let element = _parent._element {
Sample.swift:53
                _parent._element = nil
Sample.swift:101
            _element = element
 = nil as Element?
0078        private var _atEnd
Sample.swift:44
            if _parent._atEnd {
Sample.swift:56
            if _parent._atEnd {
Sample.swift:106
            _atEnd = true
 = false
0079        
0080        private let _sourceSubscription
Sample.swift:88
        _sourceSubscription.disposable = _parent._source.subscribe(self)
Sample.swift:91
        return StableCompositeDisposable.create(_sourceSubscription, samplerSubscription)
Sample.swift:107
            _sourceSubscription.dispose()
 = SingleAssignmentDisposable()
0081        
0082        init
Sample.swift:125
        let sink = SampleSequenceSink(parent: self, observer: observer)
(parent: Parent, observer: O) {
0083            _parent = parent
0084            super.init(observer: observer)
0085        }
0086        
0087        func run
Sample.swift:126
        sink.disposable = sink.run()
() -> Disposable {
0088            _sourceSubscription.disposable = _parent._source.subscribe(self)
0089            let samplerSubscription = _parent._sampler.subscribe(SamplerSink(parent: self))
0090            
0091            return StableCompositeDisposable.create(_sourceSubscription, samplerSubscription)
0092        }
0093        
0094        func on(event: Event<Element>) {
0095            synchronizedOn(event)
0096        }
0097    
0098        func _synchronized_on(event: Event<Element>) {
0099            switch event {
0100            case .Next(let element):
0101                _element = element
0102            case .Error:
0103                forwardOn(event)
0104                dispose()
0105            case .Completed:
0106                _atEnd = true
0107                _sourceSubscription.dispose()
0108            }
0109        }
0110        
0111    }
0112    
0113    class Sample
Observable+Time.swift:68
        return Sample(source: self.asObservable(), sampler: sampler.asObservable(), onlyNew: true)
Sample.swift:70
    typealias Parent = Sample<Element, SampleType>
<Element
Sample.swift:113
class Sample<Element, SampleType> : Producer<Element> {
Sample.swift:114
    private let _source: Observable<Element>
Sample.swift:118
    init(source: Observable<Element>, sampler: Observable<SampleType>, onlyNew: Bool) {
Sample.swift:124
    override func run<O: ObserverType where O.E == Element>(observer: O) -> Disposable {
, SampleType
Sample.swift:115
    private let _sampler: Observable<SampleType>
Sample.swift:118
    init(source: Observable<Element>, sampler: Observable<SampleType>, onlyNew: Bool) {
> : Producer<Element> {
0114        private let _source
Sample.swift:88
        _sourceSubscription.disposable = _parent._source.subscribe(self)
Sample.swift:119
        _source = source
: Observable<Element>
0115        private let _sampler
Sample.swift:89
        let samplerSubscription = _parent._sampler.subscribe(SamplerSink(parent: self))
Sample.swift:120
        _sampler = sampler
: Observable<SampleType>
0116        private let _onlyNew
Sample.swift:37
                if _parent._parent._onlyNew {
Sample.swift:121
        _onlyNew = onlyNew
: Bool
0117    
0118        init
Observable+Time.swift:68
        return Sample(source: self.asObservable(), sampler: sampler.asObservable(), onlyNew: true)
(source: Observable<Element>, sampler: Observable<SampleType>, onlyNew: Bool) {
0119            _source = source
0120            _sampler = sampler
0121            _onlyNew = onlyNew
0122        }
0123        
0124        override func run<O: ObserverType where O.E == Element>(observer: O) -> Disposable {
0125            let sink = SampleSequenceSink(parent: self, observer: observer)
0126            sink.disposable = sink.run()
0127            return sink
0128        }
0129    }