0001    //
0002    //  Map.swift
0003    //  Rx
0004    //
0005    //  Created by Krunoslav Zaher on 3/15/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    class MapSink
Map.swift:130
        let sink = MapSink(selector: _selector, observer: observer)
<SourceType
Map.swift:12
    typealias Selector = (SourceType) throws -> ResultType
Map.swift:15
    typealias Element = SourceType
Map.swift:24
    func on(event: Event<SourceType>) {
, O
Map.swift:11
class MapSink<SourceType, O : ObserverType> : Sink<O>, ObserverType {
Map.swift:14
    typealias ResultType = O.E
Map.swift:19
    init(selector: Selector, observer: O) {
 : ObserverType> : Sink<O>, ObserverType {
0012        typealias Selector
Map.swift:17
    private let _selector: Selector
Map.swift:19
    init(selector: Selector, observer: O) {
 = (SourceType) throws -> ResultType
0013    
0014        typealias ResultType
Map.swift:12
    typealias Selector = (SourceType) throws -> ResultType
 = O.E
0015        typealias Element = SourceType
0016    
0017        private let _selector
Map.swift:20
        _selector = selector
Map.swift:28
                let mappedElement = try _selector(element)
: Selector
0018        
0019        init
Map.swift:130
        let sink = MapSink(selector: _selector, observer: observer)
(selector: Selector, observer: O) {
0020            _selector = selector
0021            super.init(observer: observer)
0022        }
0023    
0024        func on(event: Event<SourceType>) {
0025            switch event {
0026            case .Next(let element):
0027                do {
0028                    let mappedElement = try _selector(element)
0029                    forwardOn(.Next(mappedElement))
0030                }
0031                catch let e {
0032                    forwardOn(.Error(e))
0033                    dispose()
0034                }
0035            case .Error(let error):
0036                forwardOn(.Error(error))
0037                dispose()
0038            case .Completed:
0039                forwardOn(.Completed)
0040                dispose()
0041            }
0042        }
0043    }
0044    
0045    class MapWithIndexSink
Map.swift:95
        let sink = MapWithIndexSink(selector: _selector, observer: observer)
<SourceType
Map.swift:46
    typealias Selector = (SourceType, Int) throws -> ResultType
Map.swift:49
    typealias Element = SourceType
Map.swift:50
    typealias Parent = MapWithIndex<SourceType, ResultType>
Map.swift:61
    func on(event: Event<SourceType>) {
, O
Map.swift:45
class MapWithIndexSink<SourceType, O : ObserverType> : Sink<O>, ObserverType {
Map.swift:48
    typealias ResultType = O.E
Map.swift:56
    init(selector: Selector, observer: O) {
 : ObserverType> : Sink<O>, ObserverType {
0046        typealias Selector
Map.swift:52
    private let _selector: Selector
Map.swift:56
    init(selector: Selector, observer: O) {
 = (SourceType, Int) throws -> ResultType
0047    
0048        typealias ResultType
Map.swift:46
    typealias Selector = (SourceType, Int) throws -> ResultType
Map.swift:50
    typealias Parent = MapWithIndex<SourceType, ResultType>
 = O.E
0049        typealias Element = SourceType
0050        typealias Parent = MapWithIndex<SourceType, ResultType>
0051        
0052        private let _selector
Map.swift:57
        _selector = selector
Map.swift:65
                let mappedElement = try _selector(element, try incrementChecked(&_index))
: Selector
0053    
0054        private var _index
Map.swift:65
                let mappedElement = try _selector(element, try incrementChecked(&_index))
 = 0
0055    
0056        init
Map.swift:95
        let sink = MapWithIndexSink(selector: _selector, observer: observer)
(selector: Selector, observer: O) {
0057            _selector = selector
0058            super.init(observer: observer)
0059        }
0060    
0061        func on(event: Event<SourceType>) {
0062            switch event {
0063            case .Next(let element):
0064                do {
0065                    let mappedElement = try _selector(element, try incrementChecked(&_index))
0066                    forwardOn(.Next(mappedElement))
0067                }
0068                catch let e {
0069                    forwardOn(.Error(e))
0070                    dispose()
0071                }
0072            case .Error(let error):
0073                forwardOn(.Error(error))
0074                dispose()
0075            case .Completed:
0076                forwardOn(.Completed)
0077                dispose()
0078            }
0079        }
0080    }
0081    
0082    class MapWithIndex
Map.swift:50
    typealias Parent = MapWithIndex<SourceType, ResultType>
Observable+StandardSequenceOperators.swift:192
        return MapWithIndex(source: asObservable(), selector: selector)
<SourceType
Map.swift:83
    typealias Selector = (SourceType, Int) throws -> ResultType
Map.swift:85
    private let _source: Observable<SourceType>
Map.swift:89
    init(source: Observable<SourceType>, selector: Selector) {
, ResultType
Map.swift:82
class MapWithIndex<SourceType, ResultType> : Producer<ResultType> {
Map.swift:83
    typealias Selector = (SourceType, Int) throws -> ResultType
Map.swift:94
    override func run<O: ObserverType where O.E == ResultType>(observer: O) -> Disposable {
> : Producer<ResultType> {
0083        typealias Selector
Map.swift:87
    private let _selector: Selector
Map.swift:89
    init(source: Observable<SourceType>, selector: Selector) {
 = (SourceType, Int) throws -> ResultType
0084    
0085        private let _source
Map.swift:90
        _source = source
Map.swift:96
        sink.disposable = _source.subscribe(sink)
: Observable<SourceType>
0086    
0087        private let _selector
Map.swift:91
        _selector = selector
Map.swift:95
        let sink = MapWithIndexSink(selector: _selector, observer: observer)
: Selector
0088    
0089        init
Observable+StandardSequenceOperators.swift:192
        return MapWithIndex(source: asObservable(), selector: selector)
(source: Observable<SourceType>, selector: Selector) {
0090            _source = source
0091            _selector = selector
0092        }
0093    
0094        override func run<O: ObserverType where O.E == ResultType>(observer: O) -> Disposable {
0095            let sink = MapWithIndexSink(selector: _selector, observer: observer)
0096            sink.disposable = _source.subscribe(sink)
0097            return sink
0098        }
0099    }
0100    
0101    #if TRACE_RESOURCES
0102    public var numberOfMapOperators: Int32 = 0
0103    #endif
0104    
0105    class Map
Map.swift:123
        return Map<SourceType, R>(source: _source, selector: { (s: SourceType) throws -> R in
Observable.swift:49
        return Map(source: self, selector: selector)
<SourceType
Map.swift:106
    typealias Selector = (SourceType) throws -> ResultType
Map.swift:108
    private let _source: Observable<SourceType>
Map.swift:112
    init(source: Observable<SourceType>, selector: Selector) {
Map.swift:123
        return Map<SourceType, R>(source: _source, selector: { (s: SourceType) throws -> R in
Map.swift:123
        return Map<SourceType, R>(source: _source, selector: { (s: SourceType) throws -> R in
, ResultType
Map.swift:105
class Map<SourceType, ResultType>: Producer<ResultType> {
Map.swift:106
    typealias Selector = (SourceType) throws -> ResultType
Map.swift:121
    override func composeMap<R>(selector: ResultType throws -> R) -> Observable<R> {
Map.swift:124
            let r: ResultType = try originalSelector(s)
Map.swift:129
    override func run<O: ObserverType where O.E == ResultType>(observer: O) -> Disposable {
>: Producer<ResultType> {
0106        typealias Selector
Map.swift:110
    private let _selector: Selector
Map.swift:112
    init(source: Observable<SourceType>, selector: Selector) {
 = (SourceType) throws -> ResultType
0107    
0108        private let _source
Map.swift:113
        _source = source
Map.swift:123
        return Map<SourceType, R>(source: _source, selector: { (s: SourceType) throws -> R in
Map.swift:131
        sink.disposable = _source.subscribe(sink)
: Observable<SourceType>
0109    
0110        private let _selector
Map.swift:114
        _selector = selector
Map.swift:122
        let originalSelector = _selector
Map.swift:130
        let sink = MapSink(selector: _selector, observer: observer)
: Selector
0111    
0112        init
Observable.swift:49
        return Map(source: self, selector: selector)
(source: Observable<SourceType>, selector: Selector) {
0113            _source = source
0114            _selector = selector
0115    
0116    #if TRACE_RESOURCES
0117            AtomicIncrement(&numberOfMapOperators)
0118    #endif
0119        }
0120    
0121        override func composeMap<R>(selector: ResultType throws -> R) -> Observable<R> {
0122            let originalSelector = _selector
0123            return Map<SourceType, R>(source: _source, selector: { (s: SourceType) throws -> R in
0124                let r: ResultType = try originalSelector(s)
0125                return try selector(r)
0126            })
0127        }
0128        
0129        override func run<O: ObserverType where O.E == ResultType>(observer: O) -> Disposable {
0130            let sink = MapSink(selector: _selector, observer: observer)
0131            sink.disposable = _source.subscribe(sink)
0132            return sink
0133        }
0134    
0135        #if TRACE_RESOURCES
0136        deinit {
0137            AtomicDecrement(&numberOfMapOperators)
0138        }
0139        #endif
0140    }