0001    //
0002    //  ShareReplay1WhileConnected.swift
0003    //  Rx
0004    //
0005    //  Created by Krunoslav Zaher on 12/6/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    // optimized version of share replay for most common case
0012    final class ShareReplay1WhileConnected
Observable+Binding.swift:188
        return ShareReplay1WhileConnected(source: self.asObservable())
<Element
ShareReplay1WhileConnected.swift:13
    : Observable<Element>
ShareReplay1WhileConnected.swift:17
    typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ShareReplay1WhileConnected.swift:19
    private let _source: Observable<Element>
ShareReplay1WhileConnected.swift:24
    private var _element: Element?
ShareReplay1WhileConnected.swift:25
    private var _observers = Bag<AnyObserver<Element>>()
ShareReplay1WhileConnected.swift:27
    init(source: Observable<Element>) {
>
0013        : Observable<Element>
0014        , ObserverType
0015        , SynchronizedUnsubscribeType {
0016    
0017        typealias DisposeKey
ShareReplay1WhileConnected.swift:55
    func synchronizedUnsubscribe(disposeKey: DisposeKey) {
ShareReplay1WhileConnected.swift:60
    func _synchronized_unsubscribe(disposeKey: DisposeKey) {
 = Bag<AnyObserver<Element>>.KeyType
0018    
0019        private let _source
ShareReplay1WhileConnected.swift:28
        self._source = source
ShareReplay1WhileConnected.swift:49
            connection.disposable = self._source.subscribe(self)
: Observable<Element>
0020    
0021        private var _lock
ShareReplay1WhileConnected.swift:32
        _lock.lock(); defer { _lock.unlock() }
ShareReplay1WhileConnected.swift:32
        _lock.lock(); defer { _lock.unlock() }
ShareReplay1WhileConnected.swift:56
        _lock.lock(); defer { _lock.unlock() }
ShareReplay1WhileConnected.swift:56
        _lock.lock(); defer { _lock.unlock() }
ShareReplay1WhileConnected.swift:74
        _lock.lock(); defer { _lock.unlock() }
ShareReplay1WhileConnected.swift:74
        _lock.lock(); defer { _lock.unlock() }
 = NSRecursiveLock()
0022    
0023        private var _connection
ShareReplay1WhileConnected.swift:47
            _connection = connection
ShareReplay1WhileConnected.swift:67
            _connection?.dispose()
ShareReplay1WhileConnected.swift:68
            _connection = nil
ShareReplay1WhileConnected.swift:85
            _connection?.dispose()
ShareReplay1WhileConnected.swift:86
            _connection = nil
: SingleAssignmentDisposable?
0024        private var _element
ShareReplay1WhileConnected.swift:37
        if let element = self._element {
ShareReplay1WhileConnected.swift:69
            _element = nil
ShareReplay1WhileConnected.swift:81
            _element = element
ShareReplay1WhileConnected.swift:84
            _element = nil
: Element?
0025        private var _observers
ShareReplay1WhileConnected.swift:41
        let initialCount = self._observers.count
ShareReplay1WhileConnected.swift:43
        let disposeKey = self._observers.insert(AnyObserver(observer))
ShareReplay1WhileConnected.swift:62
        if self._observers.removeKey(disposeKey) == nil {
ShareReplay1WhileConnected.swift:66
        if _observers.count == 0 {
ShareReplay1WhileConnected.swift:82
            _observers.on(event)
ShareReplay1WhileConnected.swift:87
            let observers = _observers
ShareReplay1WhileConnected.swift:88
            _observers = Bag()
 = Bag<AnyObserver<Element>>()
0026    
0027        init
Observable+Binding.swift:188
        return ShareReplay1WhileConnected(source: self.asObservable())
(source: Observable<Element>) {
0028            self._source = source
0029        }
0030    
0031        override func subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {
0032            _lock.lock(); defer { _lock.unlock() }
0033            return _synchronized_subscribe(observer)
0034        }
0035    
0036        func _synchronized_subscribe
ShareReplay1WhileConnected.swift:33
        return _synchronized_subscribe(observer)
<O : ObserverType where O.E == E>(observer: O) -> Disposable {
0037            if let element = self._element {
0038                observer.on(.Next(element))
0039            }
0040    
0041            let initialCount = self._observers.count
0042    
0043            let disposeKey = self._observers.insert(AnyObserver(observer))
0044    
0045            if initialCount == 0 {
0046                let connection = SingleAssignmentDisposable()
0047                _connection = connection
0048    
0049                connection.disposable = self._source.subscribe(self)
0050            }
0051    
0052            return SubscriptionDisposable(owner: self, key: disposeKey)
0053        }
0054    
0055        func synchronizedUnsubscribe(disposeKey: DisposeKey) {
0056            _lock.lock(); defer { _lock.unlock() }
0057            _synchronized_unsubscribe(disposeKey)
0058        }
0059    
0060        func _synchronized_unsubscribe
ShareReplay1WhileConnected.swift:57
        _synchronized_unsubscribe(disposeKey)
(disposeKey: DisposeKey) {
0061            // if already unsubscribed, just return
0062            if self._observers.removeKey(disposeKey) == nil {
0063                return
0064            }
0065    
0066            if _observers.count == 0 {
0067                _connection?.dispose()
0068                _connection = nil
0069                _element = nil
0070            }
0071        }
0072    
0073        func on(event: Event<E>) {
0074            _lock.lock(); defer { _lock.unlock() }
0075            _synchronized_on(event)
0076        }
0077    
0078        func _synchronized_on
ShareReplay1WhileConnected.swift:75
        _synchronized_on(event)
(event: Event<E>) {
0079            switch event {
0080            case .Next(let element):
0081                _element = element
0082                _observers.on(event)
0083            case .Error, .Completed:
0084                _element = nil
0085                _connection?.dispose()
0086                _connection = nil
0087                let observers = _observers
0088                _observers = Bag()
0089                observers.on(event)
0090            }
0091        }
0092    }