removed occurrences of pthread_rwlock and NSMapTable since they are not available on windows

Author: tgymnich

Sources/TSCBasic/FileSystem.swift

@@ -10,6 +10,7 @@
 
 import TSCLibc
 import Foundation
+import Dispatch
 
 public enum FileSystemError: Swift.Error {
     /// Access to the path is denied.
@@ -515,7 +516,9 @@ public class InMemoryFileSystem: FileSystem {
     /// The root filesytem.
     private var root: Node
     /// A map that keeps weak references to all locked files.
-    private let lockMap = NSMapTable<NSString, ReadWriteLock>(keyOptions: .copyIn, valueOptions: .weakMemory)
+    private var lockFiles = WeakDictionary<AbsolutePath, DispatchQueue>()
+    /// Used to access lockFiles in a thread safe manner.
+    private let lockFilesLock = Lock()
 
     public init() {
         root = Node(.directory(DirectoryContents()))
@@ -776,19 +779,18 @@ public class InMemoryFileSystem: FileSystem {
     }
 
     public func withLock<T>(on path: AbsolutePath, type: LockType = .exclusive, _ body: () throws -> T) throws -> T {
-        let lock = Lock()
-        var fileLock: ReadWriteLock
+        var fileQueue: DispatchQueue
 
-        lock.lock()
-        if let lock = lockMap.object(forKey: path.pathString as NSString) {
-            fileLock = lock
+        lockFilesLock.lock()
+        if let queue = lockFiles[path] {
+            fileQueue = queue
         } else {
-            fileLock = ReadWriteLock()
-            lockMap.setObject(fileLock, forKey: path.pathString as NSString)
+            fileQueue = DispatchQueue(label: "foo", attributes: .concurrent)
+            lockFiles[path] = fileQueue
         }
-        lock.unlock()
+        lockFilesLock.unlock()
 
-        return try fileLock.withLock(type: type, body)
+        return try fileQueue.sync(flags: type == .exclusive ? .barrier : .init() , execute: body)
     }
 }
 

Sources/TSCBasic/Lock.swift

@@ -40,44 +40,6 @@ public struct Lock {
     }
 }
 
-/// A lock that allows multiple readers but only one write at the same time.
-public class ReadWriteLock {
-    private var lock = pthread_rwlock_t()
-
-    /// Create a new lock.
-    public init() {
-        pthread_rwlock_init(&lock, nil)
-    }
-
-    func readLock() {
-        pthread_rwlock_rdlock(&lock)
-    }
-
-    func writeLock() {
-        pthread_rwlock_wrlock(&lock)
-    }
-
-    func unlock() {
-        pthread_rwlock_unlock(&lock)
-    }
-
-    /// Execute the given block while holding the lock.
-    public func withLock<T>(type lockType: LockType = .exclusive, _ body: () throws -> T) rethrows -> T {
-        switch lockType {
-        case .shared:
-            readLock()
-        case .exclusive:
-            writeLock()
-        }
-        defer { unlock() }
-        return try body()
-    }
-
-    deinit {
-        pthread_rwlock_destroy(&lock)
-    }
-}
-
 enum ProcessLockError: Swift.Error {
     case unableToAquireLock(errno: Int32)
 }

Sources/TSCBasic/WeakDictionary.swift

@@ -0,0 +1,28 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+ */
+
+/// A dictionary that only keeps weak references to its values.
+struct WeakDictionary<Key: Hashable, Value: AnyObject> {
+
+    private struct WeakReference<Value: AnyObject> {
+        weak var reference: Value?
+
+        init(_ value: Value?) {
+            self.reference = value
+        }
+    }
+
+    private var storage = Dictionary<Key, WeakReference<Value>>()
+
+    subscript(key: Key) -> Value? {
+        get { storage[key]?.reference }
+        set(newValue) { storage[key] = WeakReference(newValue) }
+    }
+}

Tests/TSCBasicTests/LockTests.swift

@@ -49,38 +49,6 @@ class LockTests: XCTestCase {
         }
     }
 
-    func testReadWriteLock() throws {
-        var a = 0
-        var b = 0
-
-        let lock = ReadWriteLock()
-
-        let writerThreads = (0..<100).map { _ in
-           return Thread {
-                lock.withLock(type: .exclusive) {
-                    a+=1
-                    sched_yield()
-                    b+=1
-                }
-            }
-        }
-
-        let readerThreads = (0..<20).map { _ in
-            return Thread {
-                lock.withLock(type: .shared) {
-                    XCTAssertEqual(a,b)
-                    sched_yield()
-                    XCTAssertEqual(a,b)
-                }
-            }
-        }
-
-        writerThreads.forEach { $0.start() }
-        readerThreads.forEach { $0.start() }
-        writerThreads.forEach { $0.join() }
-        readerThreads.forEach { $0.join() }
-    }
-
     func testReadWriteFileLock() throws {
         try withTemporaryDirectory { tempDir in
             let fileA = tempDir.appending(component: "fileA")