Initial commit :)

Author: devxoul

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Suyeol Jeon (xoul.kr)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Package.swift

@@ -0,0 +1,14 @@
+// swift-tools-version:5.1
+
+import PackageDescription
+
+let package = Package(
+  name: "WeakMapTable",
+  products: [
+    .library(name: "WeakMapTable", targets: ["WeakMapTable"]),
+  ],
+  targets: [
+    .target( name: "WeakMapTable", dependencies: []),
+    .testTarget(name: "WeakMapTableTests", dependencies: ["WeakMapTable"]),
+  ]
+)

README.md

@@ -0,0 +1,28 @@
+# WeakMapTable
+
+![Swift](https://img.shields.io/badge/Swift-5.1-orange.svg)
+[![CocoaPods](http://img.shields.io/cocoapods/v/WeakMapTable.svg)](https://cocoapods.org/pods/WeakMapTable)
+[![Build Status](https://github.com/ReactorKit/WeakMapTable/workflows/CI/badge.svg)](https://github.com/ReactorKit/WeakMapTable/actions)
+[![CodeCov](https://img.shields.io/codecov/c/github/ReactorKit/WeakMapTable.svg)](https://codecov.io/gh/ReactorKit/WeakMapTable)
+
+A weak-to-strong map table. It is inspired by [`NSMapTable`](https://developer.apple.com/documentation/foundation/nsmaptable) but **guarantees thread safety** and **deals better with weak references**. [`NSMapTable.weakToStrongObjects()`](https://developer.apple.com/documentation/foundation/nsmaptable/1391346-weaktostrongobjects) doesn't free the value object when the key object is deallocated but WeakMapTable does.
+
+## APIs
+
+```swift
+public func value(forKey key: Key) -> Value?
+public func value(forKey key: Key, default: @autoclosure () -> Value) -> Value
+public func setValue(_ value: Value?, forKey key: Key)
+```
+
+## Installation
+
+**Podfile**
+
+```ruby
+pod 'WeakMapTable'
+```
+
+## License
+
+WeakMapTable is under MIT license. See the [LICENSE](LICENSE) file for more info.

Sources/WeakMapTable/WeakMapTable.swift

@@ -0,0 +1,135 @@
+import Foundation
+
+
+// MARK: - WeakMapTable
+
+final public class WeakMapTable<Key, Value> where Key: AnyObject {
+  private var dictionary: [Weak<Key>: Value] = [:]
+  private let lock = NSRecursiveLock()
+
+
+  // MARK: Initializing
+
+  public init() {
+  }
+
+
+  // MARK: Getting and Setting Values
+
+  public func value(forKey key: Key) -> Value? {
+    let weakKey = Weak(key)
+
+    self.lock.lock()
+    defer {
+      self.lock.unlock()
+      self.installDeallocHook(to: key)
+    }
+
+    return self.unsafeValue(forKey: weakKey)
+  }
+
+  public func value(forKey key: Key, default: @autoclosure () -> Value) -> Value {
+    let weakKey = Weak(key)
+
+    self.lock.lock()
+    defer {
+      self.lock.unlock()
+      self.installDeallocHook(to: key)
+    }
+
+    if let value = self.unsafeValue(forKey: weakKey) {
+      return value
+    }
+
+    let defaultValue = `default`()
+    self.unsafeSetValue(defaultValue, forKey: weakKey)
+    return defaultValue
+  }
+
+  public func setValue(_ value: Value?, forKey key: Key) {
+    let weakKey = Weak(key)
+
+    self.lock.lock()
+    defer {
+      self.lock.unlock()
+      if value != nil {
+        self.installDeallocHook(to: key)
+      }
+    }
+
+    if let value = value {
+      self.dictionary[weakKey] = value
+    } else {
+      self.dictionary.removeValue(forKey: weakKey)
+    }
+  }
+
+
+  // MARK: Getting and Setting Values without Locking
+
+  private func unsafeValue(forKey key: Weak<Key>) -> Value? {
+    return self.dictionary[key]
+  }
+
+  private func unsafeSetValue(_ value: Value?, forKey key: Weak<Key>) {
+    if let value = value {
+      self.dictionary[key] = value
+    } else {
+      self.dictionary.removeValue(forKey: key)
+    }
+  }
+
+
+  // MARK: Dealloc Hook
+
+  private var deallocHookKey: Void?
+
+  private func installDeallocHook(to key: Key) {
+    let isInstalled = (objc_getAssociatedObject(key, &deallocHookKey) != nil)
+    guard !isInstalled else { return }
+
+    let weakKey = Weak(key)
+    let hook = DeallocHook(handler: { [weak self] in
+      self?.lock.lock()
+      self?.dictionary.removeValue(forKey: weakKey)
+      self?.lock.unlock()
+    })
+    objc_setAssociatedObject(key, &deallocHookKey, hook, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+  }
+}
+
+
+// MARK: - Weak
+
+private final class Weak<T>: Hashable where T: AnyObject {
+  private let objectHashValue: Int
+  weak var object: T?
+
+  init(_ object: T) {
+    self.objectHashValue = ObjectIdentifier(object).hashValue
+    self.object = object
+  }
+
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(self.objectHashValue)
+  }
+
+  static func == (lhs: Weak<T>, rhs: Weak<T>) -> Bool {
+    return lhs.objectHashValue == rhs.objectHashValue
+  }
+}
+
+
+// MARK: - DeallocHook
+
+private final class DeallocHook {
+  private let handler: () -> Void
+
+  init(handler: @escaping () -> Void) {
+    self.handler = handler
+  }
+
+  deinit {
+    self.handler()
+  }
+}

Tests/WeakMapTableTests/WeakMapTableTests.swift

@@ -0,0 +1,90 @@
+import XCTest
+import WeakMapTable
+
+final class WeakMapTableTests: XCTestCase {
+  func testSetValueForKey() {
+    let map = WeakMapTable<KeyObject, ValueObject>()
+
+    let (key1, value1) = (KeyObject(), ValueObject())
+    let (key2, value2) = (KeyObject(), ValueObject())
+    map.setValue(value1, forKey: key1)
+    map.setValue(value2, forKey: key2)
+
+    XCTAssert(map.value(forKey: key1) === value1)
+    XCTAssert(map.value(forKey: key2) === value2)
+  }
+
+  func testSetAnotherValue() {
+    let map = WeakMapTable<KeyObject, ValueObject>()
+
+    let key = KeyObject()
+    weak var weakOldValue: ValueObject?
+    weak var weakNewValue: ValueObject?
+
+    _ = {
+      let oldValue = ValueObject()
+      map.setValue(oldValue, forKey: key)
+      weakOldValue = oldValue
+
+      let newValue = ValueObject()
+      map.setValue(newValue, forKey: key)
+      weakNewValue = newValue
+    }()
+
+    XCTAssertNil(weakOldValue)
+    XCTAssertNotNil(weakNewValue)
+    XCTAssert(map.value(forKey: key) === weakNewValue)
+  }
+
+  func testSetNil() {
+    let map = WeakMapTable<KeyObject, ValueObject>()
+
+    let key = KeyObject()
+    weak var weakValue: ValueObject?
+
+    _ = {
+      let value = ValueObject()
+      map.setValue(value, forKey: key)
+      weakValue = value
+
+      map.setValue(nil, forKey: key)
+    }()
+
+    XCTAssertNil(map.value(forKey: key))
+    XCTAssertNil(weakValue)
+  }
+
+  func testDefaultValue() {
+    let map = WeakMapTable<KeyObject, ValueObject>()
+
+    let key = KeyObject()
+    let expectedValue = ValueObject()
+    let actualValue = map.value(forKey: key, default: expectedValue)
+
+    XCTAssert(actualValue === expectedValue)
+  }
+
+  func testReleaseKeyAndValue() {
+    let map = WeakMapTable<KeyObject, ValueObject>()
+
+    weak var weakKey: KeyObject?
+    weak var weakValue: ValueObject?
+
+    _ = {
+      let key = KeyObject()
+      let value = ValueObject()
+      map.setValue(value, forKey: key)
+      weakKey = key
+      weakValue = value
+    }()
+
+    XCTAssertNil(weakKey)
+    XCTAssertNil(weakValue)
+  }
+}
+
+private final class KeyObject {
+}
+
+private final class ValueObject {
+}