0001    //
0002    //  ShareReplay1.swift
0003    //  Rx
0004    //
0005    //  Created by Krunoslav Zaher on 10/10/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 ShareReplay1
Observable+Binding.swift:166
            return ShareReplay1(source: self.asObservable())
<Element
ShareReplay1.swift:13
    : Observable<Element>
ShareReplay1.swift:17
    typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ShareReplay1.swift:19
    private let _source: Observable<Element>
ShareReplay1.swift:24
    private var _element: Element?
ShareReplay1.swift:26
    private var _stopEvent = nil as Event<Element>?
ShareReplay1.swift:27
    private var _observers = Bag<AnyObserver<Element>>()
ShareReplay1.swift:29
    init(source: Observable<Element>) {
>
0013        : Observable<Element>
0014        , ObserverType
0015        , SynchronizedUnsubscribeType {
0016    
0017        typealias DisposeKey
ShareReplay1.swift:62
    func synchronizedUnsubscribe(disposeKey: DisposeKey) {
ShareReplay1.swift:67
    func _synchronized_unsubscribe(disposeKey: DisposeKey) {
 = Bag<AnyObserver<Element>>.KeyType
0018    
0019        private let _source
ShareReplay1.swift:30
        self._source = source
ShareReplay1.swift:56
            connection.disposable = self._source.subscribe(self)
: Observable<Element>
0020    
0021        private var _lock
ShareReplay1.swift:34
        _lock.lock(); defer { _lock.unlock() }
ShareReplay1.swift:34
        _lock.lock(); defer { _lock.unlock() }
ShareReplay1.swift:63
        _lock.lock(); defer { _lock.unlock() }
ShareReplay1.swift:63
        _lock.lock(); defer { _lock.unlock() }
ShareReplay1.swift:80
        _lock.lock(); defer { _lock.unlock() }
ShareReplay1.swift:80
        _lock.lock(); defer { _lock.unlock() }
 = NSRecursiveLock()
0022    
0023        private var _connection
ShareReplay1.swift:54
            _connection = connection
ShareReplay1.swift:74
            _connection?.dispose()
ShareReplay1.swift:75
            _connection = nil
ShareReplay1.swift:95
            _connection?.dispose()
ShareReplay1.swift:96
            _connection = nil
: SingleAssignmentDisposable?
0024        private var _element
ShareReplay1.swift:39
        if let element = self._element {
ShareReplay1.swift:91
            _element = element
: Element?
0025        private var _stopped
ShareReplay1.swift:85
        if _stopped {
ShareReplay1.swift:94
            _stopped = true
 = false
0026        private var _stopEvent
ShareReplay1.swift:43
        if let stopEvent = self._stopEvent {
ShareReplay1.swift:93
            _stopEvent = event
 = nil as Event<Element>?
0027        private var _observers
ShareReplay1.swift:48
        let initialCount = self._observers.count
ShareReplay1.swift:50
        let disposeKey = self._observers.insert(AnyObserver(observer))
ShareReplay1.swift:69
        if self._observers.removeKey(disposeKey) == nil {
ShareReplay1.swift:73
        if _observers.count == 0 {
ShareReplay1.swift:99
        _observers.on(event)
 = Bag<AnyObserver<Element>>()
0028    
0029        init
Observable+Binding.swift:166
            return ShareReplay1(source: self.asObservable())
(source: Observable<Element>) {
0030            self._source = source
0031        }
0032    
0033        override func subscribe<O : ObserverType where O.E == E>(observer: O) -> Disposable {
0034            _lock.lock(); defer { _lock.unlock() }
0035            return _synchronized_subscribe(observer)
0036        }
0037    
0038        func _synchronized_subscribe
ShareReplay1.swift:35
        return _synchronized_subscribe(observer)
<O : ObserverType where O.E == E>(observer: O) -> Disposable {
0039            if let element = self._element {
0040                observer.on(.Next(element))
0041            }
0042    
0043            if let stopEvent = self._stopEvent {
0044                observer.on(stopEvent)
0045                return NopDisposable.instance
0046            }
0047    
0048            let initialCount = self._observers.count
0049    
0050            let disposeKey = self._observers.insert(AnyObserver(observer))
0051    
0052            if initialCount == 0 {
0053                let connection = SingleAssignmentDisposable()
0054                _connection = connection
0055    
0056                connection.disposable = self._source.subscribe(self)
0057            }
0058    
0059            return SubscriptionDisposable(owner: self, key: disposeKey)
0060        }
0061    
0062        func synchronizedUnsubscribe(disposeKey: DisposeKey) {
0063            _lock.lock(); defer { _lock.unlock() }
0064            _synchronized_unsubscribe(disposeKey)
0065        }
0066    
0067        func _synchronized_unsubscribe
ShareReplay1.swift:64
        _synchronized_unsubscribe(disposeKey)
(disposeKey: DisposeKey) {
0068            // if already unsubscribed, just return
0069            if self._observers.removeKey(disposeKey) == nil {
0070                return
0071            }
0072    
0073            if _observers.count == 0 {
0074                _connection?.dispose()
0075                _connection = nil
0076            }
0077        }
0078    
0079        func on(event: Event<E>) {
0080            _lock.lock(); defer { _lock.unlock() }
0081            _synchronized_on(event)
0082        }
0083    
0084        func _synchronized_on
ShareReplay1.swift:81
        _synchronized_on(event)
(event: Event<E>) {
0085            if _stopped {
0086                return
0087            }
0088    
0089            switch event {
0090            case .Next(let element):
0091                _element = element
0092            case .Error, .Completed:
0093                _stopEvent = event
0094                _stopped = true
0095                _connection?.dispose()
0096                _connection = nil
0097            }
0098    
0099            _observers.on(event)
0100        }
0101    }