0001    //
0002    //  Bag.swift
0003    //  Rx
0004    //
0005    //  Created by Krunoslav Zaher on 2/28/15.
0006    //  Copyright © 2015 Krunoslav Zaher. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    import Swift
0011    
0012    let arrayDictionaryMaxSizeBag.swift:139         if _pairs.count < arrayDictionaryMaxSize { = 30
0013    
0014    /**
0015    Class that enables using memory allocations as a means to uniquely identify objects.
0016    */
0017    class IdentityBag.swift:34     let uniqueIdentity: Identity?
Bag.swift:75     private var _uniqueIdentity: Identity?
Bag.swift:115             _uniqueIdentity = Identity() {
0018        // weird things have known to happen with Swift
0019        var _forceAllocation: Int32 = 0
0020    }
0021    
0022    func hashBag.swift:40                 return hash(key) ^ (unsafeAddressOf(uniqueIdentity).hashValue)
Bag.swift:43                 return hash(key)(_x: Int) -> Int {
0023        var x = _x
0024        x = ((x >> 16) ^ x) &* 0x45d9f3b
0025        x = ((x >> 16) ^ x) &* 0x45d9f3b
0026        x = ((x >> 16) ^ x)
0027        return x;
0028    }
0029    
0030    /**
0031    Unique identifier for object added to `Bag`.
0032    */
0033    public struct BagKeyBag.swift:52 public func == (lhs: BagKey, rhs: BagKey) -> Bool {
Bag.swift:52 public func == (lhs: BagKey, rhs: BagKey) -> Bool {
Bag.swift:69     public typealias KeyType = BagKey
Bag.swift:73     typealias Entry = (key: BagKey, value: T)
Bag.swift:81     private var _key0: BagKey? = nil
Bag.swift:84     private var _key1: BagKey? = nil
Bag.swift:91     private var _dictionary: [BagKey : T]? = nil
Bag.swift:107     public mutating func insert(element: T) -> BagKey {
Bag.swift:118         let key = BagKey(uniqueIdentity: _uniqueIdentity, key: _nextKey)
Bag.swift:179     public mutating func removeKey(key: BagKey) -> T? { : Hashable {
0034        let uniqueIdentityBag.swift:39             if let uniqueIdentity = uniqueIdentity {
Bag.swift:53     return lhs.key == rhs.key && lhs.uniqueIdentity === rhs.uniqueIdentity
Bag.swift:53     return lhs.key == rhs.key && lhs.uniqueIdentity === rhs.uniqueIdentity: Identity?
0035        let keyBag.swift:40                 return hash(key) ^ (unsafeAddressOf(uniqueIdentity).hashValue)
Bag.swift:43                 return hash(key)
Bag.swift:53     return lhs.key == rhs.key && lhs.uniqueIdentity === rhs.uniqueIdentity
Bag.swift:53     return lhs.key == rhs.key && lhs.uniqueIdentity === rhs.uniqueIdentity: Int
0036    
0037        public var hashValue: Int {
0038            get {
0039                if let uniqueIdentity = uniqueIdentity {
0040                    return hash(key) ^ (unsafeAddressOf(uniqueIdentity).hashValue)
0041                }
0042                else {
0043                    return hash(key)
0044                }
0045            }
0046        }
0047    }
0048    
0049    /**
0050    Compares two `BagKey`s.
0051    */
0052    public func == (lhs: BagKey, rhs: BagKey) -> Bool {
0053        return lhs.key == rhs.key && lhs.uniqueIdentity === rhs.uniqueIdentity
0054    }
0055    
0056    /**
0057    Data structure that represents a bag of elements typed `T`.
0058    
0059    Single element can be stored multiple times.
0060    
0061    Time and space complexity of insertion an deletion is O(n). 
0062    
0063    It is suitable for storing small number of elements.
0064    */
0065    public struct BagBag.swift:210 extension Bag {
Bag.swift:224 extension Bag {
Bag.swift:263 extension Bag where T: ObserverType {
Bag.swift:303 public func disposeAllIn(bag: Bag<Disposable>) {
BehaviorSubject.swift:23     typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
BehaviorSubject.swift:30     private var _observers = Bag<AnyObserver<Element>>()
CompositeDisposable.swift:15     public typealias DisposeKey = Bag<Disposable>.KeyType
CompositeDisposable.swift:20     private var _disposables: Bag<Disposable>? = Bag()
CompositeDisposable.swift:20     private var _disposables: Bag<Disposable>? = Bag()
CompositeDisposable.swift:114     private func _dispose() -> Bag<Disposable>? {
Merge.swift:18     typealias DisposeKey = Bag<Disposable>.KeyType
PublishSubject.swift:24     typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
PublishSubject.swift:30     private var _observers = Bag<AnyObserver<Element>>()
ReplaySubject.swift:23     typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ReplaySubject.swift:85     private var _observers = Bag<AnyObserver<Element>>()
ShareReplay1.swift:17     typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ShareReplay1.swift:27     private var _observers = Bag<AnyObserver<Element>>()
ShareReplay1WhileConnected.swift:17     typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ShareReplay1WhileConnected.swift:25     private var _observers = Bag<AnyObserver<Element>>()
ShareReplay1WhileConnected.swift:88             _observers = Bag()<TBag.swift:73     typealias Entry = (key: BagKey, value: T)
Bag.swift:82     private var _value0: T? = nil
Bag.swift:85     private var _value1: T? = nil
Bag.swift:91     private var _dictionary: [BagKey : T]? = nil
Bag.swift:107     public mutating func insert(element: T) -> BagKey {
Bag.swift:179     public mutating func removeKey(key: BagKey) -> T? {> : CustomDebugStringConvertible {
0066        /**
0067        Type of identifier for inserted elements.
0068        */
0069        public typealias KeyTypeBehaviorSubject.swift:23     typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
CompositeDisposable.swift:15     public typealias DisposeKey = Bag<Disposable>.KeyType
Merge.swift:18     typealias DisposeKey = Bag<Disposable>.KeyType
PublishSubject.swift:24     typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ReplaySubject.swift:23     typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ShareReplay1.swift:17     typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ShareReplay1WhileConnected.swift:17     typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType = BagKey
0070        
0071        private typealias ScopeUniqueTokenTypeBag.swift:76     private var _nextKey: ScopeUniqueTokenType = 0 = Int
0072        
0073        typealias EntryBag.swift:88     private var _pairs = ContiguousArray<Entry>() = (key: BagKey, value: T)
0074     
0075        private var _uniqueIdentityBag.swift:115             _uniqueIdentity = Identity()
Bag.swift:118         let key = BagKey(uniqueIdentity: _uniqueIdentity, key: _nextKey): Identity?
0076        private var _nextKeyBag.swift:108         _nextKey = _nextKey &+ 1
Bag.swift:108         _nextKey = _nextKey &+ 1
Bag.swift:114         if _nextKey == 0 {
Bag.swift:118         let key = BagKey(uniqueIdentity: _uniqueIdentity, key: _nextKey): ScopeUniqueTokenType = 0
0077    
0078        // data
0079    
0080        // first fill inline variables
0081        private var _key0Bag.swift:120         if _key0 == nil {
Bag.swift:121             _key0 = key
Bag.swift:164         _key0 = nil
Bag.swift:180         if _key0 == key {
Bag.swift:181             _key0 = nil: BagKey? = nil
0082        private var _value0Bag.swift:122             _value0 = element
Bag.swift:157         return _pairs.count + (_value0 != nil ? 1 : 0) + (_value1 != nil ? 1 : 0) + (_dictionary?.count ?? 0)
Bag.swift:165         _value0 = nil
Bag.swift:182             let value = _value0!
Bag.swift:183             _value0 = nil
Bag.swift:232             if let value0 = _value0 {
Bag.swift:239         let value0 = _value0
Bag.swift:271             _value0?.on(event)
Bag.swift:276         let value0 = _value0
Bag.swift:305         bag._value0?.dispose()
Bag.swift:310     let value0 = bag._value0: T? = nil
0083    
0084        private var _key1Bag.swift:128         if _key1 == nil {
Bag.swift:129             _key1 = key
Bag.swift:166         _key1 = nil
Bag.swift:187         if _key1 == key {
Bag.swift:188             _key1 = nil: BagKey? = nil
0085        private var _value1Bag.swift:130             _value1 = element
Bag.swift:157         return _pairs.count + (_value0 != nil ? 1 : 0) + (_value1 != nil ? 1 : 0) + (_dictionary?.count ?? 0)
Bag.swift:167         _value1 = nil
Bag.swift:189             let value = _value1!
Bag.swift:190             _value1 = nil
Bag.swift:240         let value1 = _value1
Bag.swift:277         let value1 = _value1
Bag.swift:311     let value1 = bag._value1: T? = nil
0086    
0087        // then fill "array dictionary"
0088        private var _pairsBag.swift:139         if _pairs.count < arrayDictionaryMaxSize {
Bag.swift:140             _pairs.append(key: key, value: element)
Bag.swift:157         return _pairs.count + (_value0 != nil ? 1 : 0) + (_value1 != nil ? 1 : 0) + (_dictionary?.count ?? 0)
Bag.swift:169         _pairs.removeAll(keepCapacity: false)
Bag.swift:198         for i in 0 ..< _pairs.count {
Bag.swift:199             if _pairs[i].key == key {
Bag.swift:200                 let value = _pairs[i].value
Bag.swift:201                 _pairs.removeAtIndex(i)
Bag.swift:238         let pairs = _pairs
Bag.swift:275         let pairs = _pairs
Bag.swift:309     let pairs = bag._pairs = ContiguousArray<Entry>()
0089    
0090        // last is sparse dictionary
0091        private var _dictionaryBag.swift:134         if _dictionary != nil {
Bag.swift:135             _dictionary![key] = element
Bag.swift:144         if _dictionary == nil {
Bag.swift:145             _dictionary = [:]
Bag.swift:148         _dictionary![key] = element
Bag.swift:157         return _pairs.count + (_value0 != nil ? 1 : 0) + (_value1 != nil ? 1 : 0) + (_dictionary?.count ?? 0)
Bag.swift:170         _dictionary?.removeAll(keepCapacity: false)
Bag.swift:194         if let existingObject = _dictionary?.removeValueForKey(key) {
Bag.swift:241         let dictionary = _dictionary
Bag.swift:278         let dictionary = _dictionary
Bag.swift:312     let dictionary = bag._dictionary: [BagKey : T]? = nil
0092    
0093        private var _onlyFastPathBag.swift:126         _onlyFastPath = false
Bag.swift:231         if _onlyFastPath {
Bag.swift:270         if _onlyFastPath {
Bag.swift:304     if bag._onlyFastPath { = true
0094    
0095        /**
0096        Creates new empty `Bag`.
0097        */
0098        public initCompositeDisposable.swift:20     private var _disposables: Bag<Disposable>? = Bag()
ShareReplay1WhileConnected.swift:88             _observers = Bag()() {
0099        }
0100        
0101        /**
0102        Inserts `value` into bag.
0103        
0104        - parameter element: Element to insert.
0105        - returns: Key that can be used to remove element from bag.
0106        */
0107        public mutating func insertBehaviorSubject.swift:117         let key = _observers.insert(observer.asObserver())
CompositeDisposable.swift:36         _disposables!.insert(disposable1)
CompositeDisposable.swift:37         _disposables!.insert(disposable2)
CompositeDisposable.swift:44         _disposables!.insert(disposable1)
CompositeDisposable.swift:45         _disposables!.insert(disposable2)
CompositeDisposable.swift:46         _disposables!.insert(disposable3)
CompositeDisposable.swift:54             _disposables!.insert(disposable)
CompositeDisposable.swift:78         return _disposables?.insert(disposable)
PublishSubject.swift:100         let key = _observers.insert(observer.asObserver())
ReplaySubject.swift:145             let key = _observers.insert(AnyObserver)
ShareReplay1.swift:50         let disposeKey = self._observers.insert(AnyObserver(observer))
ShareReplay1WhileConnected.swift:43         let disposeKey = self._observers.insert(AnyObserver(observer))(element: T) -> BagKey {
0108            _nextKey = _nextKey &+ 1
0109    
0110    #if DEBUG
0111            _nextKey = _nextKey % 20
0112    #endif
0113            
0114            if _nextKey == 0 {
0115                _uniqueIdentity = Identity()
0116            }
0117    
0118            let key = BagKey(uniqueIdentity: _uniqueIdentity, key: _nextKey)
0119    
0120            if _key0 == nil {
0121                _key0 = key
0122                _value0 = element
0123                return key
0124            }
0125    
0126            _onlyFastPath = false
0127    
0128            if _key1 == nil {
0129                _key1 = key
0130                _value1 = element
0131                return key
0132            }
0133    
0134            if _dictionary != nil {
0135                _dictionary![key] = element
0136                return key
0137            }
0138    
0139            if _pairs.count < arrayDictionaryMaxSize {
0140                _pairs.append(key: key, value: element)
0141                return key
0142            }
0143    
0144            if _dictionary == nil {
0145                _dictionary = [:]
0146            }
0147    
0148            _dictionary![key] = element
0149            
0150            return key
0151        }
0152        
0153        /**
0154        - returns: Number of elements in bag.
0155        */
0156        public var countBag.swift:216             return "\(self.count) elements in Bag"
CompositeDisposable.swift:87             return _disposables?.count ?? 0
ShareReplay1.swift:48         let initialCount = self._observers.count
ShareReplay1.swift:73         if _observers.count == 0 {
ShareReplay1WhileConnected.swift:41         let initialCount = self._observers.count
ShareReplay1WhileConnected.swift:66         if _observers.count == 0 {: Int {
0157            return _pairs.count + (_value0 != nil ? 1 : 0) + (_value1 != nil ? 1 : 0) + (_dictionary?.count ?? 0)
0158        }
0159        
0160        /**
0161        Removes all elements from bag and clears capacity.
0162        */
0163        public mutating func removeAllBehaviorSubject.swift:149             _observers.removeAll()
PublishSubject.swift:73                 _observers.removeAll()
PublishSubject.swift:130         _observers.removeAll()
ReplaySubject.swift:122             _observers.removeAll()
ReplaySubject.swift:177         _observers.removeAll()() {
0164            _key0 = nil
0165            _value0 = nil
0166            _key1 = nil
0167            _value1 = nil
0168    
0169            _pairs.removeAll(keepCapacity: false)
0170            _dictionary?.removeAll(keepCapacity: false)
0171        }
0172        
0173        /**
0174        Removes element with a specific `key` from bag.
0175        
0176        - parameter key: Key that identifies element to remove from bag.
0177        - returns: Element that bag contained, or nil in case element was already removed.
0178        */
0179        public mutating func removeKeyBehaviorSubject.swift:133         _ = _observers.removeKey(disposeKey)
CompositeDisposable.swift:102         return _disposables?.removeKey(disposeKey)
PublishSubject.swift:110         _ = _observers.removeKey(disposeKey)
ReplaySubject.swift:160         _ = _observers.removeKey(disposeKey)
ShareReplay1.swift:69         if self._observers.removeKey(disposeKey) == nil {
ShareReplay1WhileConnected.swift:62         if self._observers.removeKey(disposeKey) == nil {(key: BagKey) -> T? {
0180            if _key0 == key {
0181                _key0 = nil
0182                let value = _value0!
0183                _value0 = nil
0184                return value
0185            }
0186    
0187            if _key1 == key {
0188                _key1 = nil
0189                let value = _value1!
0190                _value1 = nil
0191                return value
0192            }
0193    
0194            if let existingObject = _dictionary?.removeValueForKey(key) {
0195                return existingObject
0196            }
0197    
0198            for i in 0 ..< _pairs.count {
0199                if _pairs[i].key == key {
0200                    let value = _pairs[i].value
0201                    _pairs.removeAtIndex(i)
0202                    return value
0203                }
0204            }
0205    
0206            return nil
0207        }
0208    }
0209    
0210    extension Bag {
0211        /**
0212        A textual representation of `self`, suitable for debugging.
0213        */
0214        public var debugDescription : String {
0215            get {
0216                return "\(self.count) elements in Bag"
0217            }
0218        }
0219    }
0220    
0221    
0222    // MARK: forEach
0223    
0224    extension Bag {
0225        /**
0226        Enumerates elements inside the bag.
0227        
0228        - parameter action: Enumeration closure.
0229        */
0230        public func forEach(@noescape action: (T) -> Void) {
0231            if _onlyFastPath {
0232                if let value0 = _value0 {
0233                    action(value0)
0234                }
0235                return
0236            }
0237    
0238            let pairs = _pairs
0239            let value0 = _value0
0240            let value1 = _value1
0241            let dictionary = _dictionary
0242    
0243            if let value0 = value0 {
0244                action(value0)
0245            }
0246    
0247            if let value1 = value1 {
0248                action(value1)
0249            }
0250    
0251            for i in 0 ..< pairs.count {
0252                action(pairs[i].value)
0253            }
0254    
0255            if dictionary?.count ?? 0 > 0 {
0256                for element in dictionary!.values {
0257                    action(element)
0258                }
0259            }
0260        }
0261    }
0262    
0263    extension Bag where T: ObserverType {
0264        /**
0265         Dispatches `event` to app observers contained inside bag.
0266    
0267         - parameter action: Enumeration closure.
0268         */
0269        public func onBehaviorSubject.swift:92         _observers.on(event)
PublishSubject.swift:67             _observers.on(event)
PublishSubject.swift:72                 _observers.on(event)
ReplaySubject.swift:117             _observers.on(event)
ReplaySubject.swift:121             _observers.on(event)
ShareReplay1.swift:99         _observers.on(event)
ShareReplay1WhileConnected.swift:82             _observers.on(event)
ShareReplay1WhileConnected.swift:89             observers.on(event)(event: Event<T.E>) {
0270            if _onlyFastPath {
0271                _value0?.on(event)
0272                return
0273            }
0274    
0275            let pairs = _pairs
0276            let value0 = _value0
0277            let value1 = _value1
0278            let dictionary = _dictionary
0279    
0280            if let value0 = value0 {
0281                value0.on(event)
0282            }
0283    
0284            if let value1 = value1 {
0285                value1.on(event)
0286            }
0287    
0288            for i in 0 ..< pairs.count {
0289                pairs[i].value.on(event)
0290            }
0291    
0292            if dictionary?.count ?? 0 > 0 {
0293                for element in dictionary!.values {
0294                    element.on(event)
0295                }
0296            }
0297        }
0298    }
0299    
0300    /**
0301    Dispatches `dispose` to all disposables contained inside bag.
0302    */
0303    public func disposeAllInCompositeDisposable.swift:110             disposeAllIn(disposables)(bag: Bag<Disposable>) {
0304        if bag._onlyFastPath {
0305            bag._value0?.dispose()
0306            return
0307        }
0308    
0309        let pairs = bag._pairs
0310        let value0 = bag._value0
0311        let value1 = bag._value1
0312        let dictionary = bag._dictionary
0313    
0314        if let value0 = value0 {
0315            value0.dispose()
0316        }
0317    
0318        if let value1 = value1 {
0319            value1.dispose()
0320        }
0321    
0322        for i in 0 ..< pairs.count {
0323            pairs[i].value.dispose()
0324        }
0325    
0326        if dictionary?.count ?? 0 > 0 {
0327            for element in dictionary!.values {
0328                element.dispose()
0329            }
0330        }
0331    }
0332

Bag.swift:34	let uniqueIdentity: Identity?
Bag.swift:75	private var _uniqueIdentity: Identity?
Bag.swift:115	_uniqueIdentity = Identity()

Bag.swift:40	return hash(key) ^ (unsafeAddressOf(uniqueIdentity).hashValue)
Bag.swift:43	return hash(key)

Bag.swift:52	public func == (lhs: BagKey, rhs: BagKey) -> Bool {
Bag.swift:52	public func == (lhs: BagKey, rhs: BagKey) -> Bool {
Bag.swift:69	public typealias KeyType = BagKey
Bag.swift:73	typealias Entry = (key: BagKey, value: T)
Bag.swift:81	private var _key0: BagKey? = nil
Bag.swift:84	private var _key1: BagKey? = nil
Bag.swift:91	private var _dictionary: [BagKey : T]? = nil
Bag.swift:107	public mutating func insert(element: T) -> BagKey {
Bag.swift:118	let key = BagKey(uniqueIdentity: _uniqueIdentity, key: _nextKey)
Bag.swift:179	public mutating func removeKey(key: BagKey) -> T? {

Bag.swift:39	if let uniqueIdentity = uniqueIdentity {
Bag.swift:53	return lhs.key == rhs.key && lhs.uniqueIdentity === rhs.uniqueIdentity
Bag.swift:53	return lhs.key == rhs.key && lhs.uniqueIdentity === rhs.uniqueIdentity

Bag.swift:40	return hash(key) ^ (unsafeAddressOf(uniqueIdentity).hashValue)
Bag.swift:43	return hash(key)
Bag.swift:53	return lhs.key == rhs.key && lhs.uniqueIdentity === rhs.uniqueIdentity
Bag.swift:53	return lhs.key == rhs.key && lhs.uniqueIdentity === rhs.uniqueIdentity

Bag.swift:210	extension Bag {
Bag.swift:224	extension Bag {
Bag.swift:263	extension Bag where T: ObserverType {
Bag.swift:303	public func disposeAllIn(bag: Bag<Disposable>) {
BehaviorSubject.swift:23	typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
BehaviorSubject.swift:30	private var _observers = Bag<AnyObserver<Element>>()
CompositeDisposable.swift:15	public typealias DisposeKey = Bag<Disposable>.KeyType
CompositeDisposable.swift:20	private var _disposables: Bag<Disposable>? = Bag()
CompositeDisposable.swift:20	private var _disposables: Bag<Disposable>? = Bag()
CompositeDisposable.swift:114	private func _dispose() -> Bag<Disposable>? {
Merge.swift:18	typealias DisposeKey = Bag<Disposable>.KeyType
PublishSubject.swift:24	typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
PublishSubject.swift:30	private var _observers = Bag<AnyObserver<Element>>()
ReplaySubject.swift:23	typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ReplaySubject.swift:85	private var _observers = Bag<AnyObserver<Element>>()
ShareReplay1.swift:17	typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ShareReplay1.swift:27	private var _observers = Bag<AnyObserver<Element>>()
ShareReplay1WhileConnected.swift:17	typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ShareReplay1WhileConnected.swift:25	private var _observers = Bag<AnyObserver<Element>>()
ShareReplay1WhileConnected.swift:88	_observers = Bag()

Bag.swift:73	typealias Entry = (key: BagKey, value: T)
Bag.swift:82	private var _value0: T? = nil
Bag.swift:85	private var _value1: T? = nil
Bag.swift:91	private var _dictionary: [BagKey : T]? = nil
Bag.swift:107	public mutating func insert(element: T) -> BagKey {
Bag.swift:179	public mutating func removeKey(key: BagKey) -> T? {

BehaviorSubject.swift:23	typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
CompositeDisposable.swift:15	public typealias DisposeKey = Bag<Disposable>.KeyType
Merge.swift:18	typealias DisposeKey = Bag<Disposable>.KeyType
PublishSubject.swift:24	typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ReplaySubject.swift:23	typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ShareReplay1.swift:17	typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType
ShareReplay1WhileConnected.swift:17	typealias DisposeKey = Bag<AnyObserver<Element>>.KeyType

Bag.swift:115	_uniqueIdentity = Identity()
Bag.swift:118	let key = BagKey(uniqueIdentity: _uniqueIdentity, key: _nextKey)

Bag.swift:108	_nextKey = _nextKey &+ 1
Bag.swift:108	_nextKey = _nextKey &+ 1
Bag.swift:114	if _nextKey == 0 {
Bag.swift:118	let key = BagKey(uniqueIdentity: _uniqueIdentity, key: _nextKey)

Bag.swift:120	if _key0 == nil {
Bag.swift:121	_key0 = key
Bag.swift:164	_key0 = nil
Bag.swift:180	if _key0 == key {
Bag.swift:181	_key0 = nil

Bag.swift:122	_value0 = element
Bag.swift:157	return _pairs.count + (_value0 != nil ? 1 : 0) + (_value1 != nil ? 1 : 0) + (_dictionary?.count ?? 0)
Bag.swift:165	_value0 = nil
Bag.swift:182	let value = _value0!
Bag.swift:183	_value0 = nil
Bag.swift:232	if let value0 = _value0 {
Bag.swift:239	let value0 = _value0
Bag.swift:271	_value0?.on(event)
Bag.swift:276	let value0 = _value0
Bag.swift:305	bag._value0?.dispose()
Bag.swift:310	let value0 = bag._value0

Bag.swift:128	if _key1 == nil {
Bag.swift:129	_key1 = key
Bag.swift:166	_key1 = nil
Bag.swift:187	if _key1 == key {
Bag.swift:188	_key1 = nil

Bag.swift:130	_value1 = element
Bag.swift:157	return _pairs.count + (_value0 != nil ? 1 : 0) + (_value1 != nil ? 1 : 0) + (_dictionary?.count ?? 0)
Bag.swift:167	_value1 = nil
Bag.swift:189	let value = _value1!
Bag.swift:190	_value1 = nil
Bag.swift:240	let value1 = _value1
Bag.swift:277	let value1 = _value1
Bag.swift:311	let value1 = bag._value1

Bag.swift:139	if _pairs.count < arrayDictionaryMaxSize {
Bag.swift:140	_pairs.append(key: key, value: element)
Bag.swift:157	return _pairs.count + (_value0 != nil ? 1 : 0) + (_value1 != nil ? 1 : 0) + (_dictionary?.count ?? 0)
Bag.swift:169	_pairs.removeAll(keepCapacity: false)
Bag.swift:198	for i in 0 ..< _pairs.count {
Bag.swift:199	if _pairs[i].key == key {
Bag.swift:200	let value = _pairs[i].value
Bag.swift:201	_pairs.removeAtIndex(i)
Bag.swift:238	let pairs = _pairs
Bag.swift:275	let pairs = _pairs
Bag.swift:309	let pairs = bag._pairs

Bag.swift:134	if _dictionary != nil {
Bag.swift:135	_dictionary![key] = element
Bag.swift:144	if _dictionary == nil {
Bag.swift:145	_dictionary = [:]
Bag.swift:148	_dictionary![key] = element
Bag.swift:157	return _pairs.count + (_value0 != nil ? 1 : 0) + (_value1 != nil ? 1 : 0) + (_dictionary?.count ?? 0)
Bag.swift:170	_dictionary?.removeAll(keepCapacity: false)
Bag.swift:194	if let existingObject = _dictionary?.removeValueForKey(key) {
Bag.swift:241	let dictionary = _dictionary
Bag.swift:278	let dictionary = _dictionary
Bag.swift:312	let dictionary = bag._dictionary

Bag.swift:126	_onlyFastPath = false
Bag.swift:231	if _onlyFastPath {
Bag.swift:270	if _onlyFastPath {
Bag.swift:304	if bag._onlyFastPath {

BehaviorSubject.swift:117	let key = _observers.insert(observer.asObserver())
CompositeDisposable.swift:36	_disposables!.insert(disposable1)
CompositeDisposable.swift:37	_disposables!.insert(disposable2)
CompositeDisposable.swift:44	_disposables!.insert(disposable1)
CompositeDisposable.swift:45	_disposables!.insert(disposable2)
CompositeDisposable.swift:46	_disposables!.insert(disposable3)
CompositeDisposable.swift:54	_disposables!.insert(disposable)
CompositeDisposable.swift:78	return _disposables?.insert(disposable)
PublishSubject.swift:100	let key = _observers.insert(observer.asObserver())
ReplaySubject.swift:145	let key = _observers.insert(AnyObserver)
ShareReplay1.swift:50	let disposeKey = self._observers.insert(AnyObserver(observer))
ShareReplay1WhileConnected.swift:43	let disposeKey = self._observers.insert(AnyObserver(observer))

Bag.swift:216	return "\(self.count) elements in Bag"
CompositeDisposable.swift:87	return _disposables?.count ?? 0
ShareReplay1.swift:48	let initialCount = self._observers.count
ShareReplay1.swift:73	if _observers.count == 0 {
ShareReplay1WhileConnected.swift:41	let initialCount = self._observers.count
ShareReplay1WhileConnected.swift:66	if _observers.count == 0 {

BehaviorSubject.swift:149	_observers.removeAll()
PublishSubject.swift:73	_observers.removeAll()
PublishSubject.swift:130	_observers.removeAll()
ReplaySubject.swift:122	_observers.removeAll()
ReplaySubject.swift:177	_observers.removeAll()

BehaviorSubject.swift:133	_ = _observers.removeKey(disposeKey)
CompositeDisposable.swift:102	return _disposables?.removeKey(disposeKey)
PublishSubject.swift:110	_ = _observers.removeKey(disposeKey)
ReplaySubject.swift:160	_ = _observers.removeKey(disposeKey)
ShareReplay1.swift:69	if self._observers.removeKey(disposeKey) == nil {
ShareReplay1WhileConnected.swift:62	if self._observers.removeKey(disposeKey) == nil {

BehaviorSubject.swift:92	_observers.on(event)
PublishSubject.swift:67	_observers.on(event)
PublishSubject.swift:72	_observers.on(event)
ReplaySubject.swift:117	_observers.on(event)
ReplaySubject.swift:121	_observers.on(event)
ShareReplay1.swift:99	_observers.on(event)
ShareReplay1WhileConnected.swift:82	_observers.on(event)
ShareReplay1WhileConnected.swift:89	observers.on(event)