0001    //
0002    //  BehaviorSubject.swift
0003    //  RxSwift
0004    //
0005    //  Created by Krunoslav Zaher on 5/23/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    /**
0012    Represents a value that changes over time.
0013    
0014    Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications.
0015    */
0016    public final class BehaviorSubject
BehaviorSubject.swift:22
    public typealias SubjectObserverType = BehaviorSubject<Element>
BehaviorSubject.swift:139
    public func asObserver() -> BehaviorSubject<Element> {
Variable.swift:21
    private let _subject: BehaviorSubject<Element>
Variable.swift:56
        _subject = BehaviorSubject(value: value)<Element
BehaviorSubject.swift:17
    : Observable<Element>
BehaviorSubject.swift:22
    public typealias SubjectObserverType = BehaviorSubject<Element>
BehaviorSubject.swift:23
    typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
BehaviorSubject.swift:29
    private var _value: Element
BehaviorSubject.swift:30
    private var _observers = Bag<AnyObserver<Element>>()
BehaviorSubject.swift:31
    private var _stoppedEvent: Event<Element>?
BehaviorSubject.swift:45
    public init(value: Element) {
BehaviorSubject.swift:54
    public func value() throws -> Element {
BehaviorSubject.swift:101
    public override func subscribe<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
BehaviorSubject.swift:139
    public func asObserver() -> BehaviorSubject<Element> {>
0017        : Observable<Element>
0018        , SubjectType
0019        , ObserverType
0020        , SynchronizedUnsubscribeType
0021        , Disposable {
0022        public typealias SubjectObserverType = BehaviorSubject<Element>
0023        typealias DisposeKey
BehaviorSubject.swift:123
    func synchronizedUnsubscribe(disposeKey: DisposeKey) {
BehaviorSubject.swift:128
    func _synchronized_unsubscribe(disposeKey: DisposeKey) { = Bag<AnyObserver<Element>>.KeyType
0024        
0025        let _lock
BehaviorSubject.swift:55
        _lock.lock(); defer { _lock.unlock() } // {
BehaviorSubject.swift:55
        _lock.lock(); defer { _lock.unlock() } // {
BehaviorSubject.swift:76
        _lock.lock(); defer { _lock.unlock() }
BehaviorSubject.swift:76
        _lock.lock(); defer { _lock.unlock() }
BehaviorSubject.swift:102
        _lock.lock(); defer { _lock.unlock() }
BehaviorSubject.swift:102
        _lock.lock(); defer { _lock.unlock() }
BehaviorSubject.swift:124
        _lock.lock(); defer { _lock.unlock() }
BehaviorSubject.swift:124
        _lock.lock(); defer { _lock.unlock() }
BehaviorSubject.swift:147
        _lock.performLocked { = NSRecursiveLock()
0026        
0027        // state
0028        private var _disposed
BehaviorSubject.swift:37
        return _disposed
BehaviorSubject.swift:56
            if _disposed {
BehaviorSubject.swift:81
        if _stoppedEvent != nil || _disposed {
BehaviorSubject.swift:107
        if _disposed {
BehaviorSubject.swift:129
        if _disposed {
BehaviorSubject.swift:148
            _disposed = true = false
0029        private var _value
BehaviorSubject.swift:46
        _value = value
BehaviorSubject.swift:65
                return _value
BehaviorSubject.swift:87
            _value = value
BehaviorSubject.swift:118
        observer.on(.Next(_value)): Element
0030        private var _observers
BehaviorSubject.swift:92
        _observers.on(event)
BehaviorSubject.swift:117
        let key = _observers.insert(observer.asObserver())
BehaviorSubject.swift:133
        _ = _observers.removeKey(disposeKey)
BehaviorSubject.swift:149
            _observers.removeAll() = Bag<AnyObserver<Element>>()
0031        private var _stoppedEvent
BehaviorSubject.swift:60
            if let error = _stoppedEvent?.error {
BehaviorSubject.swift:81
        if _stoppedEvent != nil || _disposed {
BehaviorSubject.swift:89
            _stoppedEvent = event
BehaviorSubject.swift:112
        if let stoppedEvent = _stoppedEvent {
BehaviorSubject.swift:150
            _stoppedEvent = nil: Event<Element>?
0032    
0033        /**
0034        Indicates whether the subject has been disposed.
0035        */
0036        public var disposed: Bool {
0037            return _disposed
0038        }
0039     
0040        /**
0041        Initializes a new instance of the subject that caches its last value and starts with the specified value.
0042        
0043        - parameter value: Initial value sent to observers when no other value has been received by the subject yet.
0044        */
0045        public init
Variable.swift:56
        _subject = BehaviorSubject(value: value)(value: Element) {
0046            _value = value
0047        }
0048        
0049        /**
0050        Gets the current value or throws an error.
0051        
0052        - returns: Latest value.
0053        */
0054        public func value() throws -> Element {
0055            _lock.lock(); defer { _lock.unlock() } // {
0056                if _disposed {
0057                    throw RxError.Disposed(object: self)
0058                }
0059                
0060                if let error = _stoppedEvent?.error {
0061                    // intentionally throw exception
0062                    throw error
0063                }
0064                else {
0065                    return _value
0066                }
0067            //}
0068        }
0069        
0070        /**
0071        Notifies all subscribed observers about next event.
0072        
0073        - parameter event: Event to send to the observers.
0074        */
0075        public func on
Variable.swift:45
            _subject.on(.Next(newValue))
Variable.swift:67
        _subject.on(.Completed)(event: Event<E>) {
0076            _lock.lock(); defer { _lock.unlock() }
0077            _synchronized_on(event)
0078        }
0079    
0080        func _synchronized_on
BehaviorSubject.swift:77
        _synchronized_on(event)(event: Event<E>) {
0081            if _stoppedEvent != nil || _disposed {
0082                return
0083            }
0084            
0085            switch event {
0086            case .Next(let value):
0087                _value = value
0088            case .Error, .Completed:
0089                _stoppedEvent = event
0090            }
0091            
0092            _observers.on(event)
0093        }
0094        
0095        /**
0096        Subscribes an observer to the subject.
0097        
0098        - parameter observer: Observer to subscribe to the subject.
0099        - returns: Disposable object that can be used to unsubscribe the observer from the subject.
0100        */
0101        public override func subscribe<O : ObserverType where O.E == Element>(observer: O) -> Disposable {
0102            _lock.lock(); defer { _lock.unlock() }
0103            return _synchronized_subscribe(observer)
0104        }
0105    
0106        func _synchronized_subscribe
BehaviorSubject.swift:103
        return _synchronized_subscribe(observer)<O : ObserverType where O.E == E>(observer: O) -> Disposable {
0107            if _disposed {
0108                observer.on(.Error(RxError.Disposed(object: self)))
0109                return NopDisposable.instance
0110            }
0111            
0112            if let stoppedEvent = _stoppedEvent {
0113                observer.on(stoppedEvent)
0114                return NopDisposable.instance
0115            }
0116            
0117            let key = _observers.insert(observer.asObserver())
0118            observer.on(.Next(_value))
0119        
0120            return SubscriptionDisposable(owner: self, key: key)
0121        }
0122    
0123        func synchronizedUnsubscribe(disposeKey: DisposeKey) {
0124            _lock.lock(); defer { _lock.unlock() }
0125            _synchronized_unsubscribe(disposeKey)
0126        }
0127    
0128        func _synchronized_unsubscribe
BehaviorSubject.swift:125
        _synchronized_unsubscribe(disposeKey)(disposeKey: DisposeKey) {
0129            if _disposed {
0130                return
0131            }
0132    
0133            _ = _observers.removeKey(disposeKey)
0134        }
0135    
0136        /**
0137        Returns observer interface for subject.
0138        */
0139        public func asObserver() -> BehaviorSubject<Element> {
0140            return self
0141        }
0142    
0143        /**
0144        Unsubscribe all observers and release resources.
0145        */
0146        public func dispose() {
0147            _lock.performLocked {
0148                _disposed = true
0149                _observers.removeAll()
0150                _stoppedEvent = nil
0151            }
0152        }
0153    }