rename generic parameters

Author: hokuron

Sources/CacheContainer.swift

@@ -47,35 +47,35 @@ public final class CacheContainer: Sendable {
     }
 }
 
-final class ThreadSafeDictionary<V: Hashable & Sendable, T: Sendable>: Collection, @unchecked Sendable {
-    private var dictionary: [V : T]
+final class ThreadSafeDictionary<Key: Hashable & Sendable, Value: Sendable>: Collection, @unchecked Sendable {
+    private var dictionary: [Key : Value]
     private let concurrentQueue = DispatchQueue(label: "Dictionary Barrier Queue", attributes: .concurrent)
 
-    var keys: Dictionary<V, T>.Keys {
+    var keys: Dictionary<Key, Value>.Keys {
         concurrentQueue.sync { dictionary.keys }
     }
 
-    var values: Dictionary<V, T>.Values {
+    var values: Dictionary<Key, Value>.Values {
         concurrentQueue.sync { dictionary.values }
     }
 
-    var startIndex: Dictionary<V, T>.Index {
+    var startIndex: Dictionary<Key, Value>.Index {
         concurrentQueue.sync { dictionary.startIndex }
     }
 
-    var endIndex: Dictionary<V, T>.Index {
+    var endIndex: Dictionary<Key, Value>.Index {
         concurrentQueue.sync { dictionary.endIndex }
     }
 
-    init(dictionary: [V : T] = [:]) {
+    init(dictionary: [Key : Value] = [:]) {
         self.dictionary = dictionary
     }
 
-    func index(after i: Dictionary<V, T>.Index) -> Dictionary<V, T>.Index {
+    func index(after i: Dictionary<Key, Value>.Index) -> Dictionary<Key, Value>.Index {
         concurrentQueue.sync { dictionary.index(after: i) }
     }
 
-    subscript(key: V) -> T? {
+    subscript(key: Key) -> Value? {
         set(newValue) {
             concurrentQueue.async(flags: .barrier) { [weak self] in
                 self?.dictionary[key] = newValue
@@ -86,13 +86,74 @@ final class ThreadSafeDictionary<V: Hashable & Sendable, T: Sendable>: Collectio
         }
     }
 
-    subscript(index: Dictionary<V, T>.Index) -> Dictionary<V, T>.Element {
+    subscript(index: Dictionary<Key, Value>.Index) -> Dictionary<Key, Value>.Element {
         concurrentQueue.sync { dictionary[index] }
     }
 
-    func removeValue(forKey key: V) {
+    func removeValue(forKey key: Key) {
         concurrentQueue.async(flags: .barrier) { [weak self] in
             self?.dictionary.removeValue(forKey: key)
         }
     }
 }
+
+
+
+struct ThreadSafeDictionary2<Key: Hashable & Sendable, Value: Sendable> {
+    private let dictionary: Mutex<[Key: Value]>
+
+    init(dictionary: [Key : Value] = [:]) {
+        self.dictionary = Mutex(dictionary)
+    }
+
+    var keys: Dictionary<Key, Value>.Keys {
+        dictionary.withLock(\.keys)
+    }
+
+    var values: Dictionary<Key, Value>.Values {
+        dictionary.withLock(\.values)
+    }
+
+    subscript(key: Key) -> Value? {
+        get { dictionary.withLock(\.[key]) }
+        set { dictionary.withLock { $0[key] = newValue } }
+    }
+
+    @discardableResult
+    func removeValue(forKey key: Key) -> Value? {
+        dictionary.withLock { $0.removeValue(forKey: key) }
+    }
+}
+
+extension ThreadSafeDictionary2: Collection {
+    var startIndex: Dictionary<Key, Value>.Index {
+        dictionary.withLock(\.startIndex)
+    }
+    
+    var endIndex: Dictionary<Key, Value>.Index {
+        dictionary.withLock(\.endIndex)
+    }
+    
+    subscript(index: Dictionary<Key, Value>.Index) -> Dictionary<Key, Value>.Element {
+        dictionary.withLock(\.[index])
+    }
+
+    func index(after i: Dictionary<Key, Value>.Index) -> Dictionary<Key, Value>.Index {
+        dictionary.withLock { $0.index(after: i) }
+    }
+}
+
+final class Mutex<Value: ~Copyable>: @unchecked Sendable {
+    private let lock = NSLock()
+    private var value: Value
+
+    init(_ initialValue: consuming Value) {
+        self.value = initialValue
+    }
+
+    func withLock<Result: ~Copyable, E: Error>(_ body: (inout Value) throws(E) -> Result) throws(E) -> Result {
+        lock.lock()
+        defer { lock.unlock() }
+        return try body(&value)
+    }
+}