Skip to content

Commit 0397903

Browse files
niil-ohlinniil-ohlin
committed
rename _mutex to mutex
1 parent 90c9e79 commit 0397903

8 files changed

+99
-99
lines changed

‎Flow/Callbacker.swift

+11-11
Original file line numberDiff line numberDiff line change
@@ -20,20 +20,20 @@ public final class Callbacker<Value> {
2020
}
2121

2222
private var callbacks = Callbacks.none
23-
private var _mutex = pthread_mutex_t()
23+
private var mutex = pthread_mutex_t()
2424

2525
public init() {
26-
_mutex.initialize()
26+
mutex.initialize()
2727
}
2828

2929
deinit {
30-
_mutex.deinitialize()
30+
mutex.deinitialize()
3131
}
3232

3333
/// - Returns: True if no callbacks has been registered.
3434
public var isEmpty: Bool {
35-
_mutex.lock()
36-
defer { _mutex.unlock() }
35+
mutex.lock()
36+
defer { mutex.unlock() }
3737

3838
switch callbacks {
3939
case .none: return true
@@ -45,8 +45,8 @@ public final class Callbacker<Value> {
4545
/// Register a callback to be called when `callAll` is executed.
4646
/// - Returns: A `Disposable` to be disposed to unregister the callback.
4747
public func addCallback(_ callback: @escaping (Value) -> Void) -> Disposable {
48-
_mutex.lock()
49-
defer { _mutex.unlock() }
48+
mutex.lock()
49+
defer { mutex.unlock() }
5050

5151
let key = generateKey()
5252

@@ -62,8 +62,8 @@ public final class Callbacker<Value> {
6262
}
6363

6464
return NoLockKeyDisposer(key) { key in
65-
self._mutex.lock()
66-
defer { self._mutex.unlock() }
65+
self.mutex.lock()
66+
defer { self.mutex.unlock() }
6767

6868
switch self.callbacks {
6969
case .single(let singleKey, _) where singleKey == key:
@@ -81,9 +81,9 @@ public final class Callbacker<Value> {
8181

8282
/// Will call all registered callbacks with `value`
8383
public func callAll(with value: Value) {
84-
_mutex.lock()
84+
mutex.lock()
8585
let callbacks = self.callbacks
86-
_mutex.unlock()
86+
mutex.unlock()
8787

8888
switch callbacks {
8989
case .none: break

‎Flow/Disposable.swift

+16-16
Original file line numberDiff line numberDiff line change
@@ -28,24 +28,24 @@ public struct NilDisposer: Disposable {
2828
/// - Note: Is thread safe and reentrant (dispose callback could call itself)
2929
public final class Disposer: Disposable {
3030
private var disposer: (() -> ())?
31-
private var _mutex = pthread_mutex_t()
31+
private var mutex = pthread_mutex_t()
3232

3333
/// Pass a closure to be called when being disposed
3434
public init(_ disposer: @escaping () -> () = {}) {
3535
self.disposer = disposer
36-
_mutex.initialize()
36+
mutex.initialize()
3737
}
3838

3939
deinit {
4040
dispose()
41-
_mutex.deinitialize()
41+
mutex.deinitialize()
4242
}
4343

4444
public func dispose() {
45-
_mutex.lock()
45+
mutex.lock()
4646
let disposer = self.disposer
4747
self.disposer = nil
48-
_mutex.unlock()
48+
mutex.unlock()
4949
disposer?()
5050
}
5151
}
@@ -57,51 +57,51 @@ public final class Disposer: Disposable {
5757
/// - Note: New disposables could be added after a disposal.
5858
public final class DisposeBag: Disposable {
5959
private var disposables: [Disposable]
60-
private var _mutex = pthread_mutex_t()
60+
private var mutex = pthread_mutex_t()
6161

6262
/// Create an empty instance
6363
public init() {
6464
self.disposables = []
65-
_mutex.initialize()
65+
mutex.initialize()
6666
}
6767

6868
/// Create an instance already containing `disposables`
6969
public init<S: Sequence>(_ disposables: S) where S.Iterator.Element == Disposable {
7070
self.disposables = Array(disposables)
71-
_mutex.initialize()
71+
mutex.initialize()
7272
}
7373

7474
/// Create an instance already containing `disposables`
7575
public init(_ disposables: Disposable...) {
7676
self.disposables = disposables
77-
_mutex.initialize()
77+
mutex.initialize()
7878
}
7979

8080
deinit {
8181
dispose()
82-
_mutex.deinitialize()
82+
mutex.deinitialize()
8383
}
8484

8585
/// Returns true if there is currently no disposables to dispose.
8686
public var isEmpty: Bool {
87-
_mutex.lock()
87+
mutex.lock()
8888
let isEmpty = disposables.isEmpty
89-
_mutex.unlock()
89+
mutex.unlock()
9090
return isEmpty
9191
}
9292

9393
public func dispose() {
94-
_mutex.lock()
94+
mutex.lock()
9595
let disposables = self.disposables // make sure to make a copy in the case any call to dispose will recursivaly call us back.
9696
self.disposables = []
97-
_mutex.unlock()
97+
mutex.unlock()
9898
for disposable in disposables { disposable.dispose() }
9999
}
100100

101101
/// Add `disposable` to `self`
102102
public func add(_ disposable: Disposable) {
103-
_mutex.lock()
104-
defer { _mutex.unlock() }
103+
mutex.lock()
104+
defer { mutex.unlock() }
105105
disposables.append(disposable)
106106
}
107107
}

‎Flow/Future.swift

+8-8
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ public final class Future<Value> {
5757

5858
private var state: State
5959
private let clone: () -> Future
60-
private var _mutex = pthread_mutex_t()
60+
private var mutex = pthread_mutex_t()
6161

6262
/// Helper used to move external futures inside `Future.init`'s `onComplete` closure. Needed for repetition to work properly.
6363
public struct Mover {
@@ -107,7 +107,7 @@ public final class Future<Value> {
107107
try onResult(completion, Mover(shouldClone: true))
108108
}
109109
}
110-
_mutex.initialize()
110+
mutex.initialize()
111111

112112
scheduler.async {
113113
do {
@@ -143,13 +143,13 @@ public final class Future<Value> {
143143

144144
state = .completed(result)
145145
clone = { Future(result: result) }
146-
_mutex.initialize()
146+
mutex.initialize()
147147
}
148148

149149
deinit {
150150
OSAtomicDecrement32(&futureUnitTestAliveCount)
151151
memPrint("Future deinit", futureUnitTestAliveCount)
152-
_mutex.deinitialize()
152+
mutex.deinitialize()
153153
}
154154
}
155155

@@ -328,17 +328,17 @@ func memPrint(_ str: String, _ count: Int32) {
328328

329329
private extension Future {
330330
private var protectedState: State {
331-
_mutex.lock()
332-
defer { _mutex.unlock() }
331+
mutex.lock()
332+
defer { mutex.unlock() }
333333
return state
334334
}
335335

336336
func lock() {
337-
_mutex.lock()
337+
mutex.lock()
338338
}
339339

340340
func unlock() {
341-
_mutex.unlock()
341+
mutex.unlock()
342342
}
343343

344344
func completeWithResult(_ result: Result<Value>) {

‎Flow/FutureQueue.swift

+16-16
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ public final class FutureQueue<Resource> {
1818
private let queueScheduler: Scheduler
1919
private var _closedError: Error?
2020
private let isEmptyCallbacker = Callbacker<Bool>()
21-
private var _mutex = pthread_mutex_t()
21+
private var mutex = pthread_mutex_t()
2222

2323
// enqueued items.
2424
private var items: [Executable] = [] {
@@ -61,9 +61,9 @@ public extension FutureQueue {
6161
return Future { completion in
6262
let item = QueueItem<Output>(operation: operation, completion: completion)
6363

64-
self._mutex.lock()
64+
self.mutex.lock()
6565
self.items.append(item)
66-
self._mutex.unlock()
66+
self.mutex.unlock()
6767

6868
self.executeNextItem()
6969

@@ -119,8 +119,8 @@ public extension FutureQueue {
119119
public extension FutureQueue {
120120
/// Do we have any enqueued operations?
121121
var isEmpty: Bool {
122-
_mutex.lock()
123-
defer { _mutex.unlock() }
122+
mutex.lock()
123+
defer { mutex.unlock() }
124124
return items.isEmpty
125125
}
126126

@@ -166,20 +166,20 @@ public extension FutureQueue {
166166

167167
/// The error passed to `abortQueuedExecutionWithError()` if called with `shouldCloseQueue` as true.
168168
var closedError: Error? {
169-
_mutex.lock()
170-
defer { _mutex.unlock() }
169+
mutex.lock()
170+
defer { mutex.unlock() }
171171
return _closedError
172172
}
173173
}
174174

175175
private extension FutureQueue {
176-
func lock() { _mutex.lock() }
177-
func unlock() { _mutex.unlock() }
176+
func lock() { mutex.lock() }
177+
func unlock() { mutex.unlock() }
178178

179179
func removeItem(_ item: Executable) {
180-
_mutex.lock()
180+
mutex.lock()
181181
_ = items.firstIndex { $0 === item }.map { items.remove(at: $0) }
182-
_mutex.unlock()
182+
mutex.unlock()
183183
}
184184

185185
func executeNextItem() {
@@ -217,25 +217,25 @@ private final class QueueItem<Output>: Executable {
217217
private let completion: (Result<Output>) -> ()
218218
private weak var future: Future<Output>?
219219
private var hasBeenCancelled = false
220-
private var _mutex = pthread_mutex_t()
220+
private var mutex = pthread_mutex_t()
221221

222222
init(operation: @escaping () throws -> Future<Output>, completion: @escaping (Result<Output>) -> ()) {
223223
self.completion = completion
224224
self.operation = operation
225-
_mutex.initialize()
225+
mutex.initialize()
226226

227227
OSAtomicIncrement32(&queueItemUnitTestAliveCount)
228228
memPrint("Queue Item init", queueItemUnitTestAliveCount)
229229
}
230230

231231
deinit {
232-
_mutex.deinitialize()
232+
mutex.deinitialize()
233233
OSAtomicDecrement32(&queueItemUnitTestAliveCount)
234234
memPrint("Queue Item deinit", queueItemUnitTestAliveCount)
235235
}
236236

237-
private func lock() { _mutex.lock() }
238-
private func unlock() { _mutex.unlock() }
237+
private func lock() { mutex.lock() }
238+
private func unlock() { mutex.unlock() }
239239

240240
private func complete(_ result: (Result<Output>)) {
241241
lock()

‎Flow/Locking.swift

+14-14
Original file line numberDiff line numberDiff line change
@@ -10,24 +10,24 @@ import Foundation
1010

1111
/// A reference wrapper around a POSIX thread mutex
1212
public final class Mutex {
13-
private var _mutex = pthread_mutex_t()
13+
private var mutex = pthread_mutex_t()
1414

1515
public init() {
16-
_mutex.initialize()
16+
mutex.initialize()
1717
}
1818

1919
deinit {
20-
_mutex.deinitialize()
20+
mutex.deinitialize()
2121
}
2222

2323
/// Attempt to acquire the lock, blocking a thread’s execution until the lock can be acquired.
2424
public func lock() {
25-
_mutex.lock()
25+
mutex.lock()
2626
}
2727

2828
/// Releases a previously acquired lock.
2929
public func unlock() {
30-
_mutex.unlock()
30+
mutex.unlock()
3131
}
3232
}
3333

@@ -99,16 +99,16 @@ final class StateAndCallback<Value, State>: Disposable {
9999
var callback: ((Value) -> ())?
100100
var val: State
101101
fileprivate var disposables = [Disposable]()
102-
private var _mutex = pthread_mutex_t()
102+
private var mutex = pthread_mutex_t()
103103

104104
init(state: State, callback: @escaping (Value) -> ()) {
105105
val = state
106106
self.callback = callback
107-
_mutex.initialize()
107+
mutex.initialize()
108108
}
109109

110110
deinit {
111-
_mutex.deinitialize()
111+
mutex.deinitialize()
112112
dispose()
113113
}
114114

@@ -118,27 +118,27 @@ final class StateAndCallback<Value, State>: Disposable {
118118
}
119119

120120
func lock() {
121-
_mutex.lock()
121+
mutex.lock()
122122
}
123123

124124
func unlock() {
125-
_mutex.unlock()
125+
mutex.unlock()
126126
}
127127

128128
@discardableResult
129129
func protect<T>(_ block: () throws -> T) rethrows -> T {
130-
_mutex.lock()
131-
defer { _mutex.unlock() }
130+
mutex.lock()
131+
defer { mutex.unlock() }
132132
return try block()
133133
}
134134

135135
func dispose() {
136-
_mutex.lock()
136+
mutex.lock()
137137
let disposables = self.disposables // make sure to make a copy in the case any call to dispose will recursivaly call us back.
138138
callback = nil
139139
exclusiveQueue = []
140140
self.disposables = []
141-
_mutex.unlock()
141+
mutex.unlock()
142142
for disposable in disposables { disposable.dispose() }
143143
}
144144

0 commit comments

Comments
 (0)