0001    //
0002    //  TakeLast.swift
0003    //  Rx
0004    //
0005    //  Created by Tomi Koskinen on 25/10/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    
0012    class TakeLastSink
TakeLast.swift:59
        let sink = TakeLastSink(parent: self, observer: observer)
<ElementType
TakeLast.swift:13
    typealias Parent = TakeLast<ElementType>
TakeLast.swift:14
    typealias E = ElementType
TakeLast.swift:18
    private var _elements: Queue<ElementType>
TakeLast.swift:22
        _elements = Queue<ElementType>(capacity: parent._count + 1)
, O
TakeLast.swift:12
class TakeLastSink<ElementType, O: ObserverType where O.E == ElementType> : Sink<O>, ObserverType {
TakeLast.swift:20
    init(parent: Parent, observer: O) {
: ObserverType where O.E == ElementType> : Sink<O>, ObserverType {
0013        typealias Parent
TakeLast.swift:16
    private let _parent: Parent
TakeLast.swift:20
    init(parent: Parent, observer: O) {
 = TakeLast<ElementType>
0014        typealias E
TakeLast.swift:26
    func on(event: Event<E>) {
 = ElementType
0015        
0016        private let _parent
TakeLast.swift:21
        _parent = parent
TakeLast.swift:30
            if _elements.count > self._parent._count {
: Parent
0017        
0018        private var _elements
TakeLast.swift:22
        _elements = Queue<ElementType>(capacity: parent._count + 1)
TakeLast.swift:29
            _elements.enqueue(value)
TakeLast.swift:30
            if _elements.count > self._parent._count {
TakeLast.swift:31
                _elements.dequeue()
TakeLast.swift:37
            for e in _elements {
: Queue<ElementType>
0019        
0020        init
TakeLast.swift:59
        let sink = TakeLastSink(parent: self, observer: observer)
(parent: Parent, observer: O) {
0021            _parent = parent
0022            _elements = Queue<ElementType>(capacity: parent._count + 1)
0023            super.init(observer: observer)
0024        }
0025        
0026        func on(event: Event<E>) {
0027            switch event {
0028            case .Next(let value):
0029                _elements.enqueue(value)
0030                if _elements.count > self._parent._count {
0031                    _elements.dequeue()
0032                }
0033            case .Error:
0034                forwardOn(event)
0035                dispose()
0036            case .Completed:
0037                for e in _elements {
0038                    forwardOn(.Next(e))
0039                }
0040                forwardOn(.Completed)
0041                dispose()
0042            }
0043        }
0044    }
0045    
0046    class TakeLast
Observable+StandardSequenceOperators.swift:106
        return TakeLast(source: asObservable(), count: count)
TakeLast.swift:13
    typealias Parent = TakeLast<ElementType>
<Element
TakeLast.swift:46
class TakeLast<Element>: Producer<Element> {
TakeLast.swift:47
    private let _source: Observable<Element>
TakeLast.swift:50
    init(source: Observable<Element>, count: Int) {
TakeLast.swift:58
    override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
>: Producer<Element> {
0047        private let _source
TakeLast.swift:54
        _source = source
TakeLast.swift:60
        sink.disposable = _source.subscribe(sink)
: Observable<Element>
0048        private let _count
TakeLast.swift:22
        _elements = Queue<ElementType>(capacity: parent._count + 1)
TakeLast.swift:30
            if _elements.count > self._parent._count {
TakeLast.swift:55
        _count = count
: Int
0049        
0050        init
Observable+StandardSequenceOperators.swift:106
        return TakeLast(source: asObservable(), count: count)
(source: Observable<Element>, count: Int) {
0051            if count < 0 {
0052                rxFatalError("count can't be negative")
0053            }
0054            _source = source
0055            _count = count
0056        }
0057        
0058        override func run<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
0059            let sink = TakeLastSink(parent: self, observer: observer)
0060            sink.disposable = _source.subscribe(sink)
0061            return sink
0062        }
0063    }