0001    //
0002    //  Range.swift
0003    //  Rx
0004    //
0005    //  Created by Krunoslav Zaher on 9/13/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    class RangeProducer
Observable+Creation.swift:189
        return RangeProducer<E>(start: start, count: count, scheduler: scheduler)
Range.swift:38
    typealias Parent = RangeProducer<O.E>
<E
Range.swift:11
class RangeProducer<E: SignedIntegerType> : Producer<E> {
: SignedIntegerType> : Producer<E> {
0012        private let _start
Range.swift:25
        _start = start
Range.swift:50
                self.forwardOn(.Next(self._parent._start + i))
: E
0013        private let _count
Range.swift:26
        _count = count
Range.swift:49
            if i < self._parent._count {
: E
0014        private let _scheduler
Range.swift:27
        _scheduler = scheduler
Range.swift:48
        return _parent._scheduler.scheduleRecursive(0 as O.E) { i, recurse in
: ImmediateSchedulerType
0015    
0016        init(start: E, count: E, scheduler: ImmediateSchedulerType) {
0017            if count < 0 {
0018                rxFatalError("count can't be negative")
0019            }
0020    
0021            if start &+ (count - 1) < start {
0022                rxFatalError("overflow of count")
0023            }
0024    
0025            _start = start
0026            _count = count
0027            _scheduler = scheduler
0028        }
0029        
0030        override func run<O : ObserverType where O.E == E>(observer: O) -> Disposable {
0031            let sink = RangeSink(parent: self, observer: observer)
0032            sink.disposable = sink.run()
0033            return sink
0034        }
0035    }
0036    
0037    class RangeSink
Range.swift:31
        let sink = RangeSink(parent: self, observer: observer)
<O
Range.swift:37
class RangeSink<O: ObserverType where O.E: SignedIntegerType> : Sink<O> {
Range.swift:38
    typealias Parent = RangeProducer<O.E>
Range.swift:42
    init(parent: Parent, observer: O) {
Range.swift:48
        return _parent._scheduler.scheduleRecursive(0 as O.E) { i, recurse in
: ObserverType where O.E: SignedIntegerType> : Sink<O> {
0038        typealias Parent
Range.swift:40
    private let _parent: Parent
Range.swift:42
    init(parent: Parent, observer: O) {
 = RangeProducer<O.E>
0039        
0040        private let _parent
Range.swift:43
        _parent = parent
Range.swift:48
        return _parent._scheduler.scheduleRecursive(0 as O.E) { i, recurse in
Range.swift:49
            if i < self._parent._count {
Range.swift:50
                self.forwardOn(.Next(self._parent._start + i))
: Parent
0041        
0042        init
Range.swift:31
        let sink = RangeSink(parent: self, observer: observer)
(parent: Parent, observer: O) {
0043            _parent = parent
0044            super.init(observer: observer)
0045        }
0046        
0047        func run
Range.swift:32
        sink.disposable = sink.run()
() -> Disposable {
0048            return _parent._scheduler.scheduleRecursive(0 as O.E) { i, recurse in
0049                if i < self._parent._count {
0050                    self.forwardOn(.Next(self._parent._start + i))
0051                    recurse(i + 1)
0052                }
0053                else {
0054                    self.forwardOn(.Completed)
0055                    self.dispose()
0056                }
0057            }
0058        }
0059    }