0001    //
0002    //  RefCount.swift
0003    //  Rx
0004    //
0005    //  Created by Krunoslav Zaher on 3/5/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    class RefCountSink
RefCount.swift:80
        let sink = RefCountSink(parent: self, observer: observer)
<CO
RefCount.swift:15
    typealias Parent = RefCount<CO>
: ConnectableObservableType, O
RefCount.swift:12
    : Sink<O>
RefCount.swift:14
    typealias Element = O.E
RefCount.swift:19
    init(parent: Parent, observer: O) {
: ObserverType where CO.E == O.E>
0012        : Sink<O>
0013        , ObserverType {
0014        typealias Element
RefCount.swift:55
    func on(event: Event<Element>) {
 = O.E
0015        typealias Parent
RefCount.swift:17
    private let _parent: Parent
RefCount.swift:19
    init(parent: Parent, observer: O) {
 = RefCount<CO>
0016        
0017        private let _parent
RefCount.swift:20
        _parent = parent
RefCount.swift:25
        let subscription = _parent._source.subscribeSafe(self)
RefCount.swift:27
        _parent._lock.lock(); defer { _parent._lock.unlock() } // {
RefCount.swift:27
        _parent._lock.lock(); defer { _parent._lock.unlock() } // {
RefCount.swift:28
            if _parent._count == 0 {
RefCount.swift:29
                _parent._count = 1
RefCount.swift:30
                _parent._connectableSubscription = _parent._source.connect()
RefCount.swift:30
                _parent._connectableSubscription = _parent._source.connect()
RefCount.swift:33
                _parent._count = _parent._count + 1
RefCount.swift:33
                _parent._count = _parent._count + 1
RefCount.swift:39
            self._parent._lock.lock(); defer { self._parent._lock.unlock() } // {
RefCount.swift:39
            self._parent._lock.lock(); defer { self._parent._lock.unlock() } // {
RefCount.swift:40
                if self._parent._count == 1 {
RefCount.swift:41
                    self._parent._connectableSubscription!.dispose()
RefCount.swift:42
                    self._parent._count = 0
RefCount.swift:43
                    self._parent._connectableSubscription = nil
RefCount.swift:45
                else if self._parent._count > 1 {
RefCount.swift:46
                    self._parent._count = self._parent._count - 1
RefCount.swift:46
                    self._parent._count = self._parent._count - 1
: Parent
0018    
0019        init
RefCount.swift:80
        let sink = RefCountSink(parent: self, observer: observer)
(parent: Parent, observer: O) {
0020            _parent = parent
0021            super.init(observer: observer)
0022        }
0023        
0024        func run
RefCount.swift:81
        sink.disposable = sink.run()
() -> Disposable {
0025            let subscription = _parent._source.subscribeSafe(self)
0026            
0027            _parent._lock.lock(); defer { _parent._lock.unlock() } // {
0028                if _parent._count == 0 {
0029                    _parent._count = 1
0030                    _parent._connectableSubscription = _parent._source.connect()
0031                }
0032                else {
0033                    _parent._count = _parent._count + 1
0034                }
0035            // }
0036            
0037            return AnonymousDisposable {
0038                subscription.dispose()
0039                self._parent._lock.lock(); defer { self._parent._lock.unlock() } // {
0040                    if self._parent._count == 1 {
0041                        self._parent._connectableSubscription!.dispose()
0042                        self._parent._count = 0
0043                        self._parent._connectableSubscription = nil
0044                    }
0045                    else if self._parent._count > 1 {
0046                        self._parent._count = self._parent._count - 1
0047                    }
0048                    else {
0049                        rxFatalError("Something went wrong with RefCount disposing mechanism")
0050                    }
0051                // }
0052            }
0053        }
0054    
0055        func on(event: Event<Element>) {
0056            switch event {
0057            case .Next:
0058                forwardOn(event)
0059            case .Error, .Completed:
0060                forwardOn(event)
0061                dispose()
0062            }
0063        }
0064    }
0065    
0066    class RefCount
Observable+Binding.swift:125
        return RefCount(source: self)
RefCount.swift:15
    typealias Parent = RefCount<CO>
<CO
RefCount.swift:66
class RefCount<CO: ConnectableObservableType>: Producer<CO.E> {
RefCount.swift:73
    private let _source: CO
RefCount.swift:75
    init(source: CO) {
RefCount.swift:79
    override func run<O: ObserverType where O.E == CO.E>(observer: O) -> Disposable {
: ConnectableObservableType>: Producer<CO.E> {
0067        private let _lock
RefCount.swift:27
        _parent._lock.lock(); defer { _parent._lock.unlock() } // {
RefCount.swift:27
        _parent._lock.lock(); defer { _parent._lock.unlock() } // {
RefCount.swift:39
            self._parent._lock.lock(); defer { self._parent._lock.unlock() } // {
RefCount.swift:39
            self._parent._lock.lock(); defer { self._parent._lock.unlock() } // {
 = NSRecursiveLock()
0068        
0069        // state
0070        private var _count
RefCount.swift:28
            if _parent._count == 0 {
RefCount.swift:29
                _parent._count = 1
RefCount.swift:33
                _parent._count = _parent._count + 1
RefCount.swift:33
                _parent._count = _parent._count + 1
RefCount.swift:40
                if self._parent._count == 1 {
RefCount.swift:42
                    self._parent._count = 0
RefCount.swift:45
                else if self._parent._count > 1 {
RefCount.swift:46
                    self._parent._count = self._parent._count - 1
RefCount.swift:46
                    self._parent._count = self._parent._count - 1
 = 0
0071        private var _connectableSubscription
RefCount.swift:30
                _parent._connectableSubscription = _parent._source.connect()
RefCount.swift:41
                    self._parent._connectableSubscription!.dispose()
RefCount.swift:43
                    self._parent._connectableSubscription = nil
 = nil as Disposable?
0072        
0073        private let _source
RefCount.swift:25
        let subscription = _parent._source.subscribeSafe(self)
RefCount.swift:30
                _parent._connectableSubscription = _parent._source.connect()
RefCount.swift:76
        _source = source
: CO
0074        
0075        init
Observable+Binding.swift:125
        return RefCount(source: self)
(source: CO) {
0076            _source = source
0077        }
0078        
0079        override func run<O: ObserverType where O.E == CO.E>(observer: O) -> Disposable {
0080            let sink = RefCountSink(parent: self, observer: observer)
0081            sink.disposable = sink.run()
0082            return sink
0083        }
0084    }