0001    //
0002    //  RefCountDisposable.swift
0003    //  Rx
0004    //
0005    //  Created by Junior B. on 10/29/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    /**
0012        Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed.
0013     */
0014    public class RefCountDisposable
AddRef.swift:33
    private let _refCount: RefCountDisposable
AddRef.swift:35
    init(source: Observable<Element>, refCount: RefCountDisposable) {
RefCountDisposable.swift:114
    private let _parent: RefCountDisposable
RefCountDisposable.swift:117
    init(_ parent: RefCountDisposable)
Window.swift:28
    private let _refCountDisposable: RefCountDisposable
Window.swift:36
        _refCountDisposable = RefCountDisposable(disposable: _groupDisposable) : DisposeBase, Cancelable {
0015        private var _lock
RefCountDisposable.swift:25
            _lock.lock(); defer { _lock.unlock() }
RefCountDisposable.swift:25
            _lock.lock(); defer { _lock.unlock() }
RefCountDisposable.swift:44
        return _lock.calculateLocked {
RefCountDisposable.swift:64
        let oldDisposable: Disposable? = _lock.calculateLocked {
RefCountDisposable.swift:85
        let oldDisposable: Disposable? = _lock.calculateLocked { = SpinLock()
0016        private var _disposable
RefCountDisposable.swift:26
            return _disposable == nil
RefCountDisposable.swift:34
        _disposable = disposable
RefCountDisposable.swift:45
            if let _ = _disposable {
RefCountDisposable.swift:65
            if let oldDisposable = _disposable where !_primaryDisposed
RefCountDisposable.swift:71
                    _disposable = nil
RefCountDisposable.swift:86
            if let oldDisposable = _disposable {
RefCountDisposable.swift:98
                    _disposable = nil = nil as Disposable?
0017        private var _primaryDisposed
RefCountDisposable.swift:65
            if let oldDisposable = _disposable where !_primaryDisposed
RefCountDisposable.swift:67
                _primaryDisposed = true
RefCountDisposable.swift:97
                if _primaryDisposed && _count == 0 { = false
0018        private var _count
RefCountDisposable.swift:48
                    try incrementChecked(&_count)
RefCountDisposable.swift:69
                if (_count == 0)
RefCountDisposable.swift:88
                    try decrementChecked(&_count)
RefCountDisposable.swift:93
                guard _count >= 0 else {
RefCountDisposable.swift:97
                if _primaryDisposed && _count == 0 { = 
0019    
0020        /**
0021         - returns: Was resource disposed.
0022         */
0023        public var disposed: Bool {
0024            get {
0025                _lock.lock(); defer { _lock.unlock() }
0026                return _disposable == nil
0027            }
0028        }
0029    
0030        /**
0031         Initializes a new instance of the `RefCountDisposable`.
0032         */
0033        public init
Window.swift:36
        _refCountDisposable = RefCountDisposable(disposable: _groupDisposable)(disposable: Disposable) {
0034            _disposable = disposable
0035            super.init()
0036        }
0037    
0038        /**
0039         Holds a dependent disposable that when disposed decreases the refcount on the underlying disposable.
0040    
0041         When getter is called, a dependent disposable contributing to the reference count that manages the underlying disposable's lifetime is returned.
0042         */
0043        public func retain
AddRef.swift:41
        let releaseDisposable = _refCount.retain()() -> Disposable {
0044            return _lock.calculateLocked {
0045                if let _ = _disposable {
0046    
0047                    do {
0048                        try incrementChecked(&_count)
0049                    } catch (_) {
0050                        rxFatalError("RefCountDisposable increment failed")
0051                    }
0052    
0053                    return RefCountInnerDisposable(self)
0054                } else {
0055                    return NopDisposable.instance
0056                }
0057            }
0058        }
0059    
0060        /**
0061         Disposes the underlying disposable only when all dependent disposables have been disposed.
0062         */
0063        public func dispose() {
0064            let oldDisposable: Disposable? = _lock.calculateLocked {
0065                if let oldDisposable = _disposable where !_primaryDisposed
0066                {
0067                    _primaryDisposed = true
0068    
0069                    if (_count == )
0070                    {
0071                        _disposable = nil
0072                        return oldDisposable
0073                    }
0074                }
0075    
0076                return nil
0077            }
0078    
0079            if let disposable = oldDisposable {
0080                disposable.dispose()
0081            }
0082        }
0083    
0084        private func release
RefCountDisposable.swift:126
            _parent.release()() {
0085            let oldDisposable: Disposable? = _lock.calculateLocked {
0086                if let oldDisposable = _disposable {
0087                    do {
0088                        try decrementChecked(&_count)
0089                    } catch (_) {
0090                        rxFatalError("RefCountDisposable decrement on release failed")
0091                    }
0092    
0093                    guard _count >=  else {
0094                        rxFatalError("RefCountDisposable counter is lower than 0")
0095                    }
0096    
0097                    if _primaryDisposed && _count ==  {
0098                        _disposable = nil
0099                        return oldDisposable
0100                    }
0101                }
0102    
0103                return nil
0104            }
0105    
0106            if let disposable = oldDisposable {
0107                disposable.dispose()
0108            }
0109        }
0110    }
0111    
0112    internal final class RefCountInnerDisposable
RefCountDisposable.swift:53
                return RefCountInnerDisposable(self): DisposeBase, Disposable
0113    {
0114        private let _parent
RefCountDisposable.swift:119
        _parent = parent
RefCountDisposable.swift:126
            _parent.release(): RefCountDisposable
0115        private var _disposed
RefCountDisposable.swift:125
        if AtomicCompareAndSwap(0, 1, &_disposed) {: AtomicInt = 
0116    
0117        init
RefCountDisposable.swift:53
                return RefCountInnerDisposable(self)(_ parent: RefCountDisposable)
0118        {
0119            _parent = parent
0120            super.init()
0121        }
0122    
0123        internal func dispose()
0124        {
0125            if AtomicCompareAndSwap(, , &_disposed) {
0126                _parent.release()
0127            }
0128        }
0129    }
0130