xuemingqiang/ShadowsocksX-NG
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update pod RxSwift, RxCocoa to 4.5.0

Browse Source
This commit is contained in:
Qiu Yuzhou
2019-09-10 14:30:51 +08:00
parent 075949cdcb
commit 72c643eab2
238 changed files with 9425 additions and 4826 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
Pods/RxSwift/RxSwift/Subjects/AsyncSubject.swift generated
View File

@ -22,8 +22,8 @@ public final class AsyncSubject<Element>
/// Indicates whether the subject has any observers
public var hasObservers: Bool {
_lock.lock(); defer { _lock.unlock() }
return _observers.count > 0
self._lock.lock(); defer { self._lock.unlock() }
return self._observers.count > 0
}
let _lock = RecursiveLock()
@ -33,7 +33,7 @@ public final class AsyncSubject<Element>
private var _isStopped = false
private var _stoppedEvent = nil as Event<Element>? {
didSet {
_isStopped = _stoppedEvent != nil
self._isStopped = self._stoppedEvent != nil
}
}
private var _lastElement: Element?
@ -56,10 +56,10 @@ public final class AsyncSubject<Element>
/// - parameter event: Event to send to the observers.
public func on(_ event: Event<E>) {
#if DEBUG
_synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { _synchronizationTracker.unregister() }
self._synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { self._synchronizationTracker.unregister() }
#endif
let (observers, event) = _synchronized_on(event)
let (observers, event) = self._synchronized_on(event)
switch event {
case .next:
dispatch(observers, event)
@ -72,33 +72,33 @@ public final class AsyncSubject<Element>
}
func _synchronized_on(_ event: Event<E>) -> (Observers, Event<E>) {
_lock.lock(); defer { _lock.unlock() }
if _isStopped {
self._lock.lock(); defer { self._lock.unlock() }
if self._isStopped {
return (Observers(), .completed)
}
switch event {
case .next(let element):
_lastElement = element
self._lastElement = element
return (Observers(), .completed)
case .error:
_stoppedEvent = event
self._stoppedEvent = event
let observers = _observers
_observers.removeAll()
let observers = self._observers
self._observers.removeAll()
return (observers, event)
case .completed:
let observers = _observers
_observers.removeAll()
let observers = self._observers
self._observers.removeAll()
if let lastElement = _lastElement {
_stoppedEvent = .next(lastElement)
if let lastElement = self._lastElement {
self._stoppedEvent = .next(lastElement)
return (observers, .next(lastElement))
}
else {
_stoppedEvent = event
self._stoppedEvent = event
return (observers, .completed)
}
}
@ -108,13 +108,13 @@ public final class AsyncSubject<Element>
///
/// - parameter observer: Observer to subscribe to the subject.
/// - returns: Disposable object that can be used to unsubscribe the observer from the subject.
public override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
_lock.lock(); defer { _lock.unlock() }
return _synchronized_subscribe(observer)
public override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
self._lock.lock(); defer { self._lock.unlock() }
return self._synchronized_subscribe(observer)
}
func _synchronized_subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == E {
if let stoppedEvent = _stoppedEvent {
func _synchronized_subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
if let stoppedEvent = self._stoppedEvent {
switch stoppedEvent {
case .next:
observer.on(stoppedEvent)
@ -127,18 +127,18 @@ public final class AsyncSubject<Element>
return Disposables.create()
}
let key = _observers.insert(observer.on)
let key = self._observers.insert(observer.on)
return SubscriptionDisposable(owner: self, key: key)
}
func synchronizedUnsubscribe(_ disposeKey: DisposeKey) {
_lock.lock(); defer { _lock.unlock() }
_synchronized_unsubscribe(disposeKey)
self._lock.lock(); defer { self._lock.unlock() }
self._synchronized_unsubscribe(disposeKey)
}
func _synchronized_unsubscribe(_ disposeKey: DisposeKey) {
_ = _observers.removeKey(disposeKey)
_ = self._observers.removeKey(disposeKey)
}
/// Returns observer interface for subject.

74
Pods/RxSwift/RxSwift/Subjects/BehaviorSubject.swift generated
View File

@ -14,7 +14,7 @@ public final class BehaviorSubject<Element>
, SubjectType
, ObserverType
, SynchronizedUnsubscribeType
, Disposable {
, Cancelable {
public typealias SubjectObserverType = BehaviorSubject<Element>
typealias Observers = AnyObserver<Element>.s
@ -22,9 +22,9 @@ public final class BehaviorSubject<Element>
/// Indicates whether the subject has any observers
public var hasObservers: Bool {
_lock.lock()
let value = _observers.count > 0
_lock.unlock()
self._lock.lock()
let value = self._observers.count > 0
self._lock.unlock()
return value
}
@ -42,14 +42,14 @@ public final class BehaviorSubject<Element>
/// Indicates whether the subject has been disposed.
public var isDisposed: Bool {
return _isDisposed
return self._isDisposed
}
/// Initializes a new instance of the subject that caches its last value and starts with the specified value.
///
/// - parameter value: Initial value sent to observers when no other value has been received by the subject yet.
public init(value: Element) {
_element = value
self._element = value
#if TRACE_RESOURCES
_ = Resources.incrementTotal()
@ -60,17 +60,17 @@ public final class BehaviorSubject<Element>
///
/// - returns: Latest value.
public func value() throws -> Element {
_lock.lock(); defer { _lock.unlock() } // {
if _isDisposed {
self._lock.lock(); defer { self._lock.unlock() } // {
if self._isDisposed {
throw RxError.disposed(object: self)
}
if let error = _stoppedEvent?.error {
if let error = self._stoppedEvent?.error {
// intentionally throw exception
throw error
}
else {
return _element
return self._element
}
//}
}
@ -80,68 +80,68 @@ public final class BehaviorSubject<Element>
/// - parameter event: Event to send to the observers.
public func on(_ event: Event<E>) {
#if DEBUG
_synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { _synchronizationTracker.unregister() }
self._synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { self._synchronizationTracker.unregister() }
#endif
dispatch(_synchronized_on(event), event)
dispatch(self._synchronized_on(event), event)
}
func _synchronized_on(_ event: Event<E>) -> Observers {
_lock.lock(); defer { _lock.unlock() }
if _stoppedEvent != nil || _isDisposed {
self._lock.lock(); defer { self._lock.unlock() }
if self._stoppedEvent != nil || self._isDisposed {
return Observers()
}
switch event {
case .next(let element):
_element = element
self._element = element
case .error, .completed:
_stoppedEvent = event
self._stoppedEvent = event
}
return _observers
return self._observers
}
/// Subscribes an observer to the subject.
///
/// - parameter observer: Observer to subscribe to the subject.
/// - returns: Disposable object that can be used to unsubscribe the observer from the subject.
public override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
_lock.lock()
let subscription = _synchronized_subscribe(observer)
_lock.unlock()
public override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
self._lock.lock()
let subscription = self._synchronized_subscribe(observer)
self._lock.unlock()
return subscription
}
func _synchronized_subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == E {
if _isDisposed {
func _synchronized_subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
if self._isDisposed {
observer.on(.error(RxError.disposed(object: self)))
return Disposables.create()
}
if let stoppedEvent = _stoppedEvent {
if let stoppedEvent = self._stoppedEvent {
observer.on(stoppedEvent)
return Disposables.create()
}
let key = _observers.insert(observer.on)
observer.on(.next(_element))
let key = self._observers.insert(observer.on)
observer.on(.next(self._element))
return SubscriptionDisposable(owner: self, key: key)
}
func synchronizedUnsubscribe(_ disposeKey: DisposeKey) {
_lock.lock()
_synchronized_unsubscribe(disposeKey)
_lock.unlock()
self._lock.lock()
self._synchronized_unsubscribe(disposeKey)
self._lock.unlock()
}
func _synchronized_unsubscribe(_ disposeKey: DisposeKey) {
if _isDisposed {
if self._isDisposed {
return
}
_ = _observers.removeKey(disposeKey)
_ = self._observers.removeKey(disposeKey)
}
/// Returns observer interface for subject.
@ -151,11 +151,11 @@ public final class BehaviorSubject<Element>
/// Unsubscribe all observers and release resources.
public func dispose() {
_lock.lock()
_isDisposed = true
_observers.removeAll()
_stoppedEvent = nil
_lock.unlock()
self._lock.lock()
self._isDisposed = true
self._observers.removeAll()
self._stoppedEvent = nil
self._lock.unlock()
}
#if TRACE_RESOURCES

68
Pods/RxSwift/RxSwift/Subjects/PublishSubject.swift generated
View File

@ -22,9 +22,9 @@ public final class PublishSubject<Element>
/// Indicates whether the subject has any observers
public var hasObservers: Bool {
_lock.lock()
let count = _observers.count > 0
_lock.unlock()
self._lock.lock()
let count = self._observers.count > 0
self._lock.unlock()
return count
}
@ -42,7 +42,7 @@ public final class PublishSubject<Element>
/// Indicates whether the subject has been isDisposed.
public var isDisposed: Bool {
return _isDisposed
return self._isDisposed
}
/// Creates a subject.
@ -58,27 +58,27 @@ public final class PublishSubject<Element>
/// - parameter event: Event to send to the observers.
public func on(_ event: Event<Element>) {
#if DEBUG
_synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { _synchronizationTracker.unregister() }
self._synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { self._synchronizationTracker.unregister() }
#endif
dispatch(_synchronized_on(event), event)
dispatch(self._synchronized_on(event), event)
}
func _synchronized_on(_ event: Event<E>) -> Observers {
_lock.lock(); defer { _lock.unlock() }
self._lock.lock(); defer { self._lock.unlock() }
switch event {
case .next(_):
if _isDisposed || _stopped {
case .next:
if self._isDisposed || self._stopped {
return Observers()
}
return _observers
return self._observers
case .completed, .error:
if _stoppedEvent == nil {
_stoppedEvent = event
_stopped = true
let observers = _observers
_observers.removeAll()
if self._stoppedEvent == nil {
self._stoppedEvent = event
self._stopped = true
let observers = self._observers
self._observers.removeAll()
return observers
}
@ -92,36 +92,36 @@ public final class PublishSubject<Element>
- parameter observer: Observer to subscribe to the subject.
- returns: Disposable object that can be used to unsubscribe the observer from the subject.
*/
public override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
_lock.lock()
let subscription = _synchronized_subscribe(observer)
_lock.unlock()
public override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
self._lock.lock()
let subscription = self._synchronized_subscribe(observer)
self._lock.unlock()
return subscription
}
func _synchronized_subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == E {
if let stoppedEvent = _stoppedEvent {
func _synchronized_subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
if let stoppedEvent = self._stoppedEvent {
observer.on(stoppedEvent)
return Disposables.create()
}
if _isDisposed {
if self._isDisposed {
observer.on(.error(RxError.disposed(object: self)))
return Disposables.create()
}
let key = _observers.insert(observer.on)
let key = self._observers.insert(observer.on)
return SubscriptionDisposable(owner: self, key: key)
}
func synchronizedUnsubscribe(_ disposeKey: DisposeKey) {
_lock.lock()
_synchronized_unsubscribe(disposeKey)
_lock.unlock()
self._lock.lock()
self._synchronized_unsubscribe(disposeKey)
self._lock.unlock()
}
func _synchronized_unsubscribe(_ disposeKey: DisposeKey) {
_ = _observers.removeKey(disposeKey)
_ = self._observers.removeKey(disposeKey)
}
/// Returns observer interface for subject.
@ -131,15 +131,15 @@ public final class PublishSubject<Element>
/// Unsubscribe all observers and release resources.
public func dispose() {
_lock.lock()
_synchronized_dispose()
_lock.unlock()
self._lock.lock()
self._synchronized_dispose()
self._lock.unlock()
}
final func _synchronized_dispose() {
_isDisposed = true
_observers.removeAll()
_stoppedEvent = nil
self._isDisposed = true
self._observers.removeAll()
self._stoppedEvent = nil
}
#if TRACE_RESOURCES

100
Pods/RxSwift/RxSwift/Subjects/ReplaySubject.swift generated
View File

@ -21,9 +21,9 @@ public class ReplaySubject<Element>
/// Indicates whether the subject has any observers
public var hasObservers: Bool {
_lock.lock()
let value = _observers.count > 0
_lock.unlock()
self._lock.lock()
let value = self._observers.count > 0
self._lock.unlock()
return value
}
@ -34,7 +34,7 @@ public class ReplaySubject<Element>
fileprivate var _isStopped = false
fileprivate var _stoppedEvent = nil as Event<Element>? {
didSet {
_isStopped = _stoppedEvent != nil
self._isStopped = self._stoppedEvent != nil
}
}
fileprivate var _observers = Observers()
@ -48,7 +48,7 @@ public class ReplaySubject<Element>
}
final var isStopped: Bool {
return _isStopped
return self._isStopped
}
/// Notifies all subscribed observers about next event.
@ -98,7 +98,7 @@ public class ReplaySubject<Element>
#endif
}
fileprivate class ReplayBufferBase<Element>
private class ReplayBufferBase<Element>
: ReplaySubject<Element>
, SynchronizedUnsubscribeType {
@ -116,91 +116,91 @@ fileprivate class ReplayBufferBase<Element>
override func on(_ event: Event<Element>) {
#if DEBUG
_synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { _synchronizationTracker.unregister() }
self._synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { self._synchronizationTracker.unregister() }
#endif
dispatch(_synchronized_on(event), event)
dispatch(self._synchronized_on(event), event)
}
func _synchronized_on(_ event: Event<E>) -> Observers {
_lock.lock(); defer { _lock.unlock() }
if _isDisposed {
self._lock.lock(); defer { self._lock.unlock() }
if self._isDisposed {
return Observers()
}
if _isStopped {
if self._isStopped {
return Observers()
}
switch event {
case .next(let element):
addValueToBuffer(element)
trim()
return _observers
self.addValueToBuffer(element)
self.trim()
return self._observers
case .error, .completed:
_stoppedEvent = event
trim()
let observers = _observers
_observers.removeAll()
self._stoppedEvent = event
self.trim()
let observers = self._observers
self._observers.removeAll()
return observers
}
}
override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
_lock.lock()
let subscription = _synchronized_subscribe(observer)
_lock.unlock()
override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
self._lock.lock()
let subscription = self._synchronized_subscribe(observer)
self._lock.unlock()
return subscription
}
func _synchronized_subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == E {
if _isDisposed {
func _synchronized_subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
if self._isDisposed {
observer.on(.error(RxError.disposed(object: self)))
return Disposables.create()
}
let anyObserver = observer.asObserver()
replayBuffer(anyObserver)
if let stoppedEvent = _stoppedEvent {
self.replayBuffer(anyObserver)
if let stoppedEvent = self._stoppedEvent {
observer.on(stoppedEvent)
return Disposables.create()
}
else {
let key = _observers.insert(observer.on)
let key = self._observers.insert(observer.on)
return SubscriptionDisposable(owner: self, key: key)
}
}
func synchronizedUnsubscribe(_ disposeKey: DisposeKey) {
_lock.lock()
_synchronized_unsubscribe(disposeKey)
_lock.unlock()
self._lock.lock()
self._synchronized_unsubscribe(disposeKey)
self._lock.unlock()
}
func _synchronized_unsubscribe(_ disposeKey: DisposeKey) {
if _isDisposed {
if self._isDisposed {
return
}
_ = _observers.removeKey(disposeKey)
_ = self._observers.removeKey(disposeKey)
}
override func dispose() {
super.dispose()
synchronizedDispose()
self.synchronizedDispose()
}
func synchronizedDispose() {
_lock.lock()
_synchronized_dispose()
_lock.unlock()
self._lock.lock()
self._synchronized_dispose()
self._lock.unlock()
}
func _synchronized_dispose() {
_isDisposed = true
_observers.removeAll()
self._isDisposed = true
self._observers.removeAll()
}
}
@ -216,41 +216,41 @@ fileprivate final class ReplayOne<Element> : ReplayBufferBase<Element> {
}
override func addValueToBuffer(_ value: Element) {
_value = value
self._value = value
}
override func replayBuffer<O: ObserverType>(_ observer: O) where O.E == Element {
if let value = _value {
if let value = self._value {
observer.on(.next(value))
}
}
override func _synchronized_dispose() {
super._synchronized_dispose()
_value = nil
self._value = nil
}
}
fileprivate class ReplayManyBase<Element> : ReplayBufferBase<Element> {
private class ReplayManyBase<Element>: ReplayBufferBase<Element> {
fileprivate var _queue: Queue<Element>
init(queueSize: Int) {
_queue = Queue(capacity: queueSize + 1)
self._queue = Queue(capacity: queueSize + 1)
}
override func addValueToBuffer(_ value: Element) {
_queue.enqueue(value)
self._queue.enqueue(value)
}
override func replayBuffer<O: ObserverType>(_ observer: O) where O.E == Element {
for item in _queue {
for item in self._queue {
observer.on(.next(item))
}
}
override func _synchronized_dispose() {
super._synchronized_dispose()
_queue = Queue(capacity: 0)
self._queue = Queue(capacity: 0)
}
}
@ -258,14 +258,14 @@ fileprivate final class ReplayMany<Element> : ReplayManyBase<Element> {
private let _bufferSize: Int
init(bufferSize: Int) {
_bufferSize = bufferSize
self._bufferSize = bufferSize
super.init(queueSize: bufferSize)
}
override func trim() {
while _queue.count > _bufferSize {
_ = _queue.dequeue()
while self._queue.count > self._bufferSize {
_ = self._queue.dequeue()
}
}
}