feat: Add ThreadSafeArray and ThreadSafeDictionary

Implements thread-safe wrappers for standard Swift collection types using the ThreadSafe<T> pattern.

Author: rickhohler

Sources/DesignAlgorithmsKit/Structural/ThreadSafeArray.swift

@@ -0,0 +1,98 @@
+// DesignAlgorithmsKit
+// Structural Pattern: ThreadSafe Array
+//
+// A thread-safe wrapper around a standard Swift Array.
+// Uses ThreadSafe<[Element]> internally.
+
+import Foundation
+
+/// A thread-safe array wrapper.
+/// Provides safe concurrent access to an array using an internal lock.
+public final class ThreadSafeArray<Element>: @unchecked Sendable {
+    private let storage: ThreadSafe<[Element]>
+    
+    public init(_ array: [Element] = []) {
+        self.storage = ThreadSafe(array)
+    }
+    
+    /// The number of elements in the array.
+    public var count: Int {
+        storage.read { $0.count }
+    }
+    
+    /// A Boolean value indicating whether the collection is empty.
+    public var isEmpty: Bool {
+        storage.read { $0.isEmpty }
+    }
+    
+    /// Adds a new element at the end of the array.
+    public func append(_ newElement: Element) {
+        storage.write { $0.append(newElement) }
+    }
+    
+    /// Adds the elements of a sequence to the end of the array.
+    public func append<S>(contentsOf newElements: S) where S : Sequence, Element == S.Element {
+        storage.write { $0.append(contentsOf: newElements) }
+    }
+    
+    /// Removes and returns the element at the specified position.
+    public func remove(at index: Int) -> Element {
+        storage.write { $0.remove(at: index) }
+    }
+    
+    /// Removes all elements from the array.
+    public func removeAll(keepingCapacity keepCapacity: Bool = false) {
+        storage.write { $0.removeAll(keepingCapacity: keepCapacity) }
+    }
+    
+    /// Accesses the element at the specified position.
+    /// Note: This is not efficient for iteration. Use `read` or `map` for batch operations.
+    public subscript(index: Int) -> Element {
+        get {
+            storage.read { $0[index] }
+        }
+        set {
+            storage.write { $0[index] = newValue }
+        }
+    }
+    
+    /// Returns an array containing the results of mapping the given closure over the sequence’s elements.
+    public func map<T>(_ transform: (Element) throws -> T) rethrows -> [T] {
+        try storage.read { try $0.map(transform) }
+    }
+    
+    /// Returns an array containing the non-nil results of calling the given transformation with each element of this sequence.
+    public func compactMap<T>(_ transform: (Element) throws -> T?) rethrows -> [T] {
+        try storage.read { try $0.compactMap(transform) }
+    }
+    
+    /// Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.
+    public func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element] {
+        try storage.read { try $0.filter(isIncluded) }
+    }
+    
+    /// Returns the first element of the sequence that satisfies the given predicate.
+    public func first(where predicate: (Element) throws -> Bool) rethrows -> Element? {
+        try storage.read { try $0.first(where: predicate) }
+    }
+    
+    /// Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.
+    public func contains(where predicate: (Element) throws -> Bool) rethrows -> Bool {
+        try storage.read { try $0.contains(where: predicate) }
+    }
+    
+    /// Returns a new array containing the elements of this array.
+    public var allElements: [Element] {
+        storage.read { $0 }
+    }
+    
+    /// Execute a block with the array for reading
+    public func read<Result>(_ block: ([Element]) throws -> Result) rethrows -> Result {
+        try storage.read(block)
+    }
+    
+    /// Execute a block with the array for writing
+    public func write<Result>(_ block: (inout [Element]) throws -> Result) rethrows -> Result {
+        try storage.write(block)
+    }
+}

Sources/DesignAlgorithmsKit/Structural/ThreadSafeDictionary.swift

@@ -0,0 +1,87 @@
+// DesignAlgorithmsKit
+// Structural Pattern: ThreadSafe Dictionary
+//
+// A thread-safe wrapper around a standard Swift Dictionary.
+// Uses ThreadSafe<[Key: Value]> internally.
+
+import Foundation
+
+/// A thread-safe dictionary wrapper.
+/// Provides safe concurrent access to a dictionary using an internal lock.
+public final class ThreadSafeDictionary<Key: Hashable, Value>: @unchecked Sendable {
+    private let storage: ThreadSafe<[Key: Value]>
+    
+    public init(_ dictionary: [Key: Value] = [:]) {
+        self.storage = ThreadSafe(dictionary)
+    }
+    
+    /// The number of key-value pairs in the dictionary.
+    public var count: Int {
+        storage.read { $0.count }
+    }
+    
+    /// A Boolean value indicating whether the dictionary is empty.
+    public var isEmpty: Bool {
+        storage.read { $0.isEmpty }
+    }
+    
+    /// Accesses the value associated with the given key for reading and writing.
+    public subscript(key: Key) -> Value? {
+        get {
+            storage.read { $0[key] }
+        }
+        set {
+            storage.write { $0[key] = newValue }
+        }
+    }
+    
+    /// Accesses the value with the given key. If the dictionary doesn’t contain the given key, accesses the provided default value as if the key and default value existed in the dictionary.
+    public subscript(key: Key, default defaultValue: @autoclosure () -> Value) -> Value {
+        get {
+            storage.read { $0[key, default: defaultValue()] }
+        }
+        set {
+            storage.write { $0[key, default: defaultValue()] = newValue }
+        }
+    }
+    
+    /// Updates the value stored in the dictionary for the given key, or adds a new key-value pair if the key does not exist.
+    public func updateValue(_ value: Value, forKey key: Key) -> Value? {
+        storage.write { $0.updateValue(value, forKey: key) }
+    }
+    
+    /// Removes the value associated with the given key.
+    public func removeValue(forKey key: Key) -> Value? {
+        storage.write { $0.removeValue(forKey: key) }
+    }
+    
+    /// Removes all key-value pairs from the dictionary.
+    public func removeAll(keepingCapacity keepCapacity: Bool = false) {
+        storage.write { $0.removeAll(keepingCapacity: keepCapacity) }
+    }
+    
+    /// Returns a new dictionary containing the keys and values of this dictionary.
+    public var all: [Key: Value] {
+        storage.read { $0 }
+    }
+    
+    /// Returns a collection containing just the keys of the dictionary.
+    public var keys: [Key] {
+        storage.read { Array($0.keys) }
+    }
+    
+    /// Returns a collection containing just the values of the dictionary.
+    public var values: [Value] {
+        storage.read { Array($0.values) }
+    }
+    
+    /// Execute a block with the dictionary for reading
+    public func read<Result>(_ block: ([Key: Value]) throws -> Result) rethrows -> Result {
+        try storage.read(block)
+    }
+    
+    /// Execute a block with the dictionary for writing
+    public func write<Result>(_ block: (inout [Key: Value]) throws -> Result) rethrows -> Result {
+        try storage.write(block)
+    }
+}