CommandLineToolkit

1
import Dispatch
2
import Foundation
3

4
@propertyWrapper
5
public final class AtomicValue<T> {
6
    private var value: T
7
    private let lock = NSRecursiveLock()
8

9
    public init(_ value: T) {
10
        self.value = value
11
    }
12
    
13
    public init(wrappedValue: T) {
14
        self.value = wrappedValue
15
    }
16
    
17
    public var wrappedValue: T {
18
        get { currentValue() }
19
        set { set(newValue) }
20
        _modify {
21
            lock.lock()
22
            defer { lock.unlock() }
23
            yield &value
24
        }
25
    }
26

27
    public var projectedValue: AtomicValue {
28
        return self
29
    }
30

31
    @discardableResult
32
    public func withExclusiveAccess<R>(work: (inout T) throws -> R) rethrows -> R {
33
        lock.lock()
34
        defer { lock.unlock() }
35
        return try work(&value)
36
    }
37
    
38
    public func currentValue() -> T {
39
        lock.lock()
40
        defer { lock.unlock() }
41
        return value
42
    }
43
    
44
    public func set(_ newValue: T) {
45
        lock.lock()
46
        defer { lock.unlock() }
47
        value = newValue
48
    }
49
}
50