0001    //
0002    //  SerialDisposable.swift
0003    //  Rx
0004    //
0005    //  Created by Krunoslav Zaher on 3/12/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    /**
0012    Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource.
0013    */
0014    public class SerialDisposable
Buffer.swift:45
    private let _timerD = SerialDisposable()
Catch.swift:40
    private let _subscription = SerialDisposable()
ObserveOn.swift:56
    let _scheduleDisposable = SerialDisposable()
SubscribeOn.swift:31
        let disposeEverything = SerialDisposable()
Switch.swift:19
    private let _innerSubscription: SerialDisposable = SerialDisposable()
Switch.swift:19
    private let _innerSubscription: SerialDisposable = SerialDisposable()
TailRecursiveSink.swift:30
    var _subscription = SerialDisposable()
Throttle.swift:27
    let cancellable = SerialDisposable()
Timeout.swift:19
    private let _timerD = SerialDisposable()
Timeout.swift:20
    private let _subscription = SerialDisposable()
Window.swift:27
    private let _timerD = SerialDisposable()
 : DisposeBase, Cancelable {
0015        private var _lock
SerialDisposable.swift:46
            return _lock.calculateLocked {
SerialDisposable.swift:51
            let disposable: Disposable? = _lock.calculateLocked {
SerialDisposable.swift:76
        _lock.lock(); defer { _lock.unlock() }
SerialDisposable.swift:76
        _lock.lock(); defer { _lock.unlock() }
 = SpinLock()
0016        
0017        // state
0018        private var _current
SerialDisposable.swift:56
                    let toDispose = _current
SerialDisposable.swift:57
                    _current = newDisposable
SerialDisposable.swift:82
            let current = _current
SerialDisposable.swift:83
            _current = nil
 = nil as Disposable?
0019        private var _disposed
SerialDisposable.swift:26
            return _disposed
SerialDisposable.swift:52
                if _disposed {
SerialDisposable.swift:77
        if _disposed {
SerialDisposable.swift:81
            _disposed = true
 = false
0020        
0021        /**
0022        - returns: Was resource disposed.
0023        */
0024        public var disposed
Buffer.swift:95
        if _timerD.disposed {
Timeout.swift:75
        if _timerD.disposed {
Window.swift:99
        if _timerD.disposed {
: Bool {
0025            get {
0026                return _disposed
0027            }
0028        }
0029        
0030        /**
0031        Initializes a new instance of the `SerialDisposable`.
0032        */
0033        override public init
Buffer.swift:45
    private let _timerD = SerialDisposable()
Catch.swift:40
    private let _subscription = SerialDisposable()
ObserveOn.swift:56
    let _scheduleDisposable = SerialDisposable()
SubscribeOn.swift:31
        let disposeEverything = SerialDisposable()
Switch.swift:19
    private let _innerSubscription: SerialDisposable = SerialDisposable()
TailRecursiveSink.swift:30
    var _subscription = SerialDisposable()
Throttle.swift:27
    let cancellable = SerialDisposable()
Timeout.swift:19
    private let _timerD = SerialDisposable()
Timeout.swift:20
    private let _subscription = SerialDisposable()
Window.swift:27
    private let _timerD = SerialDisposable()
() {
0034            super.init()
0035        }
0036        
0037        /**
0038        Gets or sets the underlying disposable.
0039        
0040        Assigning this property disposes the previous disposable object.
0041        
0042        If the `SerialDisposable` has already been disposed, assignment to this property causes immediate disposal of the given disposable object.
0043        */
0044        public var disposable
Buffer.swift:105
        _timerD.disposable = nextTimer
Catch.swift:49
        _subscription.disposable = d1
Catch.swift:68
                _subscription.disposable = catchSequence.subscribe(observer)
ObserveOn.swift:78
            _scheduleDisposable.disposable = self._scheduler.scheduleRecursive((), action: self.run)
SerialDisposable.swift:47
                return self.disposable
SubscribeOn.swift:34
        disposeEverything.disposable = cancelSchedule
SubscribeOn.swift:38
            disposeEverything.disposable = ScheduledDisposable(scheduler: self.parent.scheduler, disposable: subscription)
Switch.swift:56
                _innerSubscription.disposable = d
TailRecursiveSink.swift:131
        _subscription.disposable = disposable
Throttle.swift:57
            self.cancellable.disposable = d
Timeout.swift:32
        _subscription.disposable = original
Timeout.swift:80
        _timerD.disposable = nextTimer
Timeout.swift:92
                self._subscription.disposable = self._parent._other.subscribeSafe(self.forwarder())
Window.swift:109
        _timerD.disposable = nextTimer
: Disposable {
0045            get {
0046                return _lock.calculateLocked {
0047                    return self.disposable
0048                }
0049            }
0050            set (newDisposable) {
0051                let disposable: Disposable? = _lock.calculateLocked {
0052                    if _disposed {
0053                        return newDisposable
0054                    }
0055                    else {
0056                        let toDispose = _current
0057                        _current = newDisposable
0058                        return toDispose
0059                    }
0060                }
0061                
0062                if let disposable = disposable {
0063                    disposable.dispose()
0064                }
0065            }
0066        }
0067        
0068        /**
0069        Disposes the underlying disposable as well as all future replacements.
0070        */
0071        public func dispose
ObserveOn.swift:126
        _scheduleDisposable.dispose()
TailRecursiveSink.swift:147
        _subscription.dispose()
() {
0072            _dispose()?.dispose()
0073        }
0074    
0075        private func _dispose
SerialDisposable.swift:72
        _dispose()?.dispose()
() -> Disposable? {
0076            _lock.lock(); defer { _lock.unlock() }
0077            if _disposed {
0078                return nil
0079            }
0080            else {
0081                _disposed = true
0082                let current = _current
0083                _current = nil
0084                return current
0085            }
0086        }
0087    }