From 01304bcff7d30ea82fbdd518e48d8665c26b3942 Mon Sep 17 00:00:00 2001 From: yury Date: Sat, 17 Oct 2015 18:19:47 +0300 Subject: [PATCH] More work on private vars --- .../Observables/Implementations/Switch.swift | 76 +++++++++---------- .../Observables/Implementations/Take.swift | 64 ++++++++-------- .../Implementations/TakeUntil.swift | 57 +++++++------- .../Implementations/Throttle.swift | 54 ++++++------- .../Observables/Implementations/Timer.swift | 26 +++---- 5 files changed, 137 insertions(+), 140 deletions(-) diff --git a/RxSwift/Observables/Implementations/Switch.swift b/RxSwift/Observables/Implementations/Switch.swift index 8465b71e..10fa9071 100644 --- a/RxSwift/Observables/Implementations/Switch.swift +++ b/RxSwift/Observables/Implementations/Switch.swift @@ -12,58 +12,58 @@ class SwitchSink typealias E = S typealias Parent = Switch - let subscriptions: SingleAssignmentDisposable = SingleAssignmentDisposable() - let innerSubscription: SerialDisposable = SerialDisposable() - let parent: Parent + private let _subscriptions: SingleAssignmentDisposable = SingleAssignmentDisposable() + private let _innerSubscription: SerialDisposable = SerialDisposable() + private let _parent: Parent - let lock = NSRecursiveLock() + private let _lock = NSRecursiveLock() // state - var stopped = false - var latest = 0 - var hasLatest = false + private var _stopped = false + private var _latest = 0 + private var _hasLatest = false init(parent: Parent, observer: O, cancel: Disposable) { - self.parent = parent + _parent = parent super.init(observer: observer, cancel: cancel) } func run() -> Disposable { - let subscription = self.parent.sources.subscribeSafe(self) - subscriptions.disposable = subscription - return CompositeDisposable(subscriptions, innerSubscription) + let subscription = _parent._sources.subscribeSafe(self) + _subscriptions.disposable = subscription + return CompositeDisposable(_subscriptions, _innerSubscription) } func on(event: Event) { switch event { case .Next(let observable): - let latest: Int = self.lock.calculateLocked { - hasLatest = true - self.latest = self.latest &+ 1 - return self.latest + let latest: Int = _lock.calculateLocked { + _hasLatest = true + _latest = _latest &+ 1 + return _latest } let d = SingleAssignmentDisposable() - innerSubscription.disposable = d + _innerSubscription.disposable = d let observer = SwitchSinkIter(parent: self, id: latest, _self: d) let disposable = observable.asObservable().subscribeSafe(observer) d.disposable = disposable case .Error(let error): - self.lock.performLocked { + _lock.performLocked { observer?.on(.Error(error)) - self.dispose() + dispose() } case .Completed: - self.lock.performLocked { - self.stopped = true + _lock.performLocked { + _stopped = true - self.subscriptions.dispose() + _subscriptions.dispose() - if !self.hasLatest { + if !_hasLatest { observer?.on(.Completed) - self.dispose() + dispose() } } } @@ -74,42 +74,42 @@ class SwitchSinkIter - let parent: Parent - let id: Int - let _self: Disposable + private let _parent: Parent + private let _id: Int + private let _self: Disposable init(parent: Parent, id: Int, _self: Disposable) { - self.parent = parent - self.id = id + _parent = parent + _id = id self._self = _self } func on(event: Event) { - return parent.lock.calculateLocked { + return _parent._lock.calculateLocked { switch event { case .Next: break case .Error, .Completed: - self._self.dispose() + _self.dispose() } - if parent.latest != self.id { + if _parent._latest != _id { return } - let observer = self.parent.observer + let observer = _parent.observer switch event { case .Next: observer?.on(event) case .Error: observer?.on(event) - self.parent.dispose() + _parent.dispose() case .Completed: - parent.hasLatest = false - if parent.stopped { + _parent._hasLatest = false + if _parent._stopped { observer?.on(event) - self.parent.dispose() + _parent.dispose() } } } @@ -117,10 +117,10 @@ class SwitchSinkIter : Producer { - let sources: Observable + private let _sources: Observable init(sources: Observable) { - self.sources = sources + _sources = sources } override func run(observer: O, cancel: Disposable, setSink: (Disposable) -> Void) -> Disposable { diff --git a/RxSwift/Observables/Implementations/Take.swift b/RxSwift/Observables/Implementations/Take.swift index 98d60db6..ca9054d1 100644 --- a/RxSwift/Observables/Implementations/Take.swift +++ b/RxSwift/Observables/Implementations/Take.swift @@ -14,13 +14,13 @@ class TakeCountSink : Sin typealias Parent = TakeCount typealias E = ElementType - let parent: Parent + private let _parent: Parent - var remaining: Int + private var _remaining: Int init(parent: Parent, observer: O, cancel: Disposable) { - self.parent = parent - self.remaining = parent.count + _parent = parent + _remaining = parent._count super.init(observer: observer, cancel: cancel) } @@ -28,40 +28,40 @@ class TakeCountSink : Sin switch event { case .Next(let value): - if remaining > 0 { - remaining-- + if _remaining > 0 { + _remaining-- observer?.on(.Next(value)) - if remaining == 0 { + if _remaining == 0 { observer?.on(.Completed) - self.dispose() + dispose() } } case .Error: observer?.on(event) - self.dispose() + dispose() case .Completed: observer?.on(event) - self.dispose() + dispose() } } } class TakeCount: Producer { - let source: Observable - let count: Int + private let _source: Observable + private let _count: Int init(source: Observable, count: Int) { - self.source = source - self.count = count + _source = source + _count = count } override func run(observer: O, cancel: Disposable, setSink: (Disposable) -> Void) -> Disposable { let sink = TakeCountSink(parent: self, observer: observer, cancel: cancel) setSink(sink) - return source.subscribeSafe(sink) + return _source.subscribeSafe(sink) } } @@ -71,44 +71,44 @@ class TakeTimeSink typealias E = ElementType - let parent: Parent + private let _parent: Parent - let lock = NSRecursiveLock() + private let _lock = NSRecursiveLock() init(parent: Parent, observer: O, cancel: Disposable) { - self.parent = parent + _parent = parent super.init(observer: observer, cancel: cancel) } func on(event: Event) { - lock.performLocked { + _lock.performLocked { switch event { case .Next(let value): observer?.on(.Next(value)) case .Error: observer?.on(event) - self.dispose() + dispose() case .Completed: observer?.on(event) - self.dispose() + dispose() } } } func tick() { - lock.performLocked { - self.observer?.on(.Completed) - self.dispose() + _lock.performLocked { + observer?.on(.Completed) + dispose() } } func run() -> Disposable { - let disposeTimer = parent.scheduler.scheduleRelative((), dueTime: self.parent.duration) { + let disposeTimer = _parent._scheduler.scheduleRelative((), dueTime: _parent._duration) { self.tick() return NopDisposable.instance } - let disposeSubscription = parent.source.subscribeSafe(self) + let disposeSubscription = _parent._source.subscribeSafe(self) return BinaryDisposable(disposeTimer, disposeSubscription) } @@ -117,14 +117,14 @@ class TakeTimeSink: Producer { typealias TimeInterval = S.TimeInterval - let source: Observable - let duration: TimeInterval - let scheduler: S + private let _source: Observable + private let _duration: TimeInterval + private let _scheduler: S init(source: Observable, duration: TimeInterval, scheduler: S) { - self.source = source - self.scheduler = scheduler - self.duration = duration + _source = source + _scheduler = scheduler + _duration = duration } override func run(observer: O, cancel: Disposable, setSink: (Disposable) -> Void) -> Disposable { diff --git a/RxSwift/Observables/Implementations/TakeUntil.swift b/RxSwift/Observables/Implementations/TakeUntil.swift index f791a4c2..77b273b3 100644 --- a/RxSwift/Observables/Implementations/TakeUntil.swift +++ b/RxSwift/Observables/Implementations/TakeUntil.swift @@ -12,38 +12,38 @@ class TakeUntilSinkOther typealias E = Other - let parent: Parent + private let _parent: Parent - let singleAssignmentDisposable = SingleAssignmentDisposable() + private let _singleAssignmentDisposable = SingleAssignmentDisposable() var disposable: Disposable { get { abstractMethod() } set(value) { - singleAssignmentDisposable.disposable = value + _singleAssignmentDisposable.disposable = value } } init(parent: Parent) { - self.parent = parent + _parent = parent #if TRACE_RESOURCES OSAtomicIncrement32(&resourceCount) #endif } func on(event: Event) { - parent.lock.performLocked { + _parent._lock.performLocked { switch event { case .Next: - parent.observer?.on(.Completed) - parent.dispose() + _parent.observer?.on(.Completed) + _parent.dispose() case .Error(let e): - parent.observer?.on(.Error(e)) - parent.dispose() + _parent.observer?.on(.Error(e)) + _parent.dispose() case .Completed: - parent.open = true - singleAssignmentDisposable.dispose() + _parent._open = true + _singleAssignmentDisposable.dispose() } } } @@ -59,50 +59,47 @@ class TakeUntilSink - let parent: Parent + private let _parent: Parent - let lock = NSRecursiveLock() + private let _lock = NSRecursiveLock() // state - var open = false + private var _open = false init(parent: Parent, observer: O, cancel: Disposable) { - self.parent = parent + _parent = parent super.init(observer: observer, cancel: cancel) } func on(event: Event) { switch event { case .Next: - if open { + if _open { observer?.on(event) } else { - lock.performLocked { + _lock.performLocked { observer?.on(event) } } - break case .Error: - lock.performLocked { + _lock.performLocked { observer?.on(event) - self.dispose() + dispose() } - break case .Completed: - lock.performLocked { + _lock.performLocked { observer?.on(event) - self.dispose() + dispose() } - break } } func run() -> Disposable { let otherObserver = TakeUntilSinkOther(parent: self) - let otherSubscription = parent.other.subscribeSafe(otherObserver) + let otherSubscription = _parent._other.subscribeSafe(otherObserver) otherObserver.disposable = otherSubscription - let sourceSubscription = parent.source.subscribeSafe(self) + let sourceSubscription = _parent._source.subscribeSafe(self) return CompositeDisposable(sourceSubscription, otherSubscription) } @@ -110,12 +107,12 @@ class TakeUntilSink: Producer { - let source: Observable - let other: Observable + private let _source: Observable + private let _other: Observable init(source: Observable, other: Observable) { - self.source = source - self.other = other + _source = source + _other = other } override func run(observer: O, cancel: Disposable, setSink: (Disposable) -> Void) -> Disposable { diff --git a/RxSwift/Observables/Implementations/Throttle.swift b/RxSwift/Observables/Implementations/Throttle.swift index cbe16da4..4d881c3e 100644 --- a/RxSwift/Observables/Implementations/Throttle.swift +++ b/RxSwift/Observables/Implementations/Throttle.swift @@ -12,24 +12,24 @@ class ThrottleSink : Sink, Observe typealias Element = O.E typealias ParentType = Throttle - let parent: ParentType + private let _parent: ParentType - let lock = NSRecursiveLock() + private let _lock = NSRecursiveLock() // state - var id = 0 as UInt64 - var value: Element? = nil + private var _id = 0 as UInt64 + private var _value: Element? = nil let cancellable = SerialDisposable() init(parent: ParentType, observer: O, cancel: Disposable) { - self.parent = parent + _parent = parent super.init(observer: observer, cancel: cancel) } func run() -> Disposable { - let subscription = parent.source.subscribeSafe(self) + let subscription = _parent._source.subscribeSafe(self) return CompositeDisposable(subscription, cancellable) } @@ -42,40 +42,40 @@ class ThrottleSink : Sink, Observe cancellable.dispose() } - let latestId = self.lock.calculateLocked { () -> UInt64 in + let latestId = _lock.calculateLocked { () -> UInt64 in let observer = self.observer - let oldValue = self.value + let oldValue = _value - self.id = self.id &+ 1 + _id = _id &+ 1 switch event { case .Next(let element): - self.value = element + _value = element case .Error: - self.value = nil + _value = nil observer?.on(event) - self.dispose() + dispose() case .Completed: - self.value = nil + _value = nil if let value = oldValue { observer?.on(.Next(value)) } observer?.on(.Completed) - self.dispose() + dispose() } - return id + return _id } switch event { - case .Next(_): + case .Next: let d = SingleAssignmentDisposable() self.cancellable.disposable = d - let scheduler = self.parent.scheduler - let dueTime = self.parent.dueTime + let scheduler = _parent._scheduler + let dueTime = _parent._dueTime let disposeTimer = scheduler.scheduleRelative(latestId, dueTime: dueTime) { (id) in self.propagate() @@ -88,9 +88,9 @@ class ThrottleSink : Sink, Observe } func propagate() { - let originalValue: Element? = self.lock.calculateLocked { - let originalValue = self.value - self.value = nil + let originalValue: Element? = _lock.calculateLocked { + let originalValue = _value + _value = nil return originalValue } @@ -102,14 +102,14 @@ class ThrottleSink : Sink, Observe class Throttle : Producer { - let source: Observable - let dueTime: Scheduler.TimeInterval - let scheduler: Scheduler + private let _source: Observable + private let _dueTime: Scheduler.TimeInterval + private let _scheduler: Scheduler init(source: Observable, dueTime: Scheduler.TimeInterval, scheduler: Scheduler) { - self.source = source - self.dueTime = dueTime - self.scheduler = scheduler + _source = source + _dueTime = dueTime + _scheduler = scheduler } override func run(observer: O, cancel: Disposable, setSink: (Disposable) -> Void) -> Disposable { diff --git a/RxSwift/Observables/Implementations/Timer.swift b/RxSwift/Observables/Implementations/Timer.swift index 98a76a6e..35f2839f 100644 --- a/RxSwift/Observables/Implementations/Timer.swift +++ b/RxSwift/Observables/Implementations/Timer.swift @@ -11,15 +11,15 @@ import Foundation class TimerSink : Sink { typealias Parent = Timer - let parent: Parent + private let _parent: Parent init(parent: Parent, observer: O, cancel: Disposable) { - self.parent = parent + _parent = parent super.init(observer: observer, cancel: cancel) } func run() -> Disposable { - return self.parent.scheduler.schedulePeriodic(0 as Int64, startAfter: self.parent.dueTime, period: self.parent.period!) { state in + return _parent._scheduler.schedulePeriodic(0 as Int64, startAfter: _parent._dueTime, period: _parent._period!) { state in self.observer?.on(.Next(state)) return state &+ 1 } @@ -29,15 +29,15 @@ class TimerSink : Sink class TimerOneOffSink : Sink { typealias Parent = Timer - let parent: Parent + private let _parent: Parent init(parent: Parent, observer: O, cancel: Disposable) { - self.parent = parent + _parent = parent super.init(observer: observer, cancel: cancel) } func run() -> Disposable { - return self.parent.scheduler.scheduleRelative((), dueTime: self.parent.dueTime) { (_) -> Disposable in + return _parent._scheduler.scheduleRelative((), dueTime: _parent._dueTime) { (_) -> Disposable in self.observer?.on(.Next(0)) self.observer?.on(.Completed) @@ -49,18 +49,18 @@ class TimerOneOffSink : Si class Timer: Producer { typealias TimeInterval = S.TimeInterval - let scheduler: S - let dueTime: TimeInterval - let period: TimeInterval? + private let _scheduler: S + private let _dueTime: TimeInterval + private let _period: TimeInterval? init(dueTime: TimeInterval, period: TimeInterval?, scheduler: S) { - self.scheduler = scheduler - self.dueTime = dueTime - self.period = period + _scheduler = scheduler + _dueTime = dueTime + _period = period } override func run(observer: O, cancel: Disposable, setSink: (Disposable) -> Void) -> Disposable { - if let _ = period { + if let _ = _period { let sink = TimerSink(parent: self, observer: observer, cancel: cancel) setSink(sink) return sink.run()