Initial Commit

Author: amayers

.gitignore

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

.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

.swiftpm/xcode/package.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,29 @@
+// swift-tools-version:5.3
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "ThreadKit",
+    platforms: [.iOS(.v12), .macOS(.v10_15), .watchOS(.v6), .tvOS(.v12)],
+    products: [
+        // Products define the executables and libraries a package produces, and make them visible to other packages.
+        .library(
+            name: "ThreadKit",
+            targets: ["ThreadKit"]),
+    ],
+    dependencies: [
+        // Dependencies declare other packages that this package depends on.
+        // .package(url: /* package url */, from: "1.0.0"),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+        // Targets can depend on other targets in this package, and on products in packages this package depends on.
+        .target(
+            name: "ThreadKit",
+            dependencies: []),
+        .testTarget(
+            name: "ThreadKitTests",
+            dependencies: ["ThreadKit"]),
+    ]
+)

Package.swift

@@ -0,0 +1,3 @@
+# ThreadKit
+
+A bunch of threading related helpers. Things like atomics, and stuff.

README.md

@@ -0,0 +1,38 @@
+import Foundation
+
+/// A property wrapper that ensures atomic access to a value. IE only one thing can write at a time.
+/// Multiple things can potentially read at the same time, just not during a write.
+/// By using `pthread` to do the locking, this safer then using a `DispatchQueue/barrier` as there isn't a chance
+/// of priority inversion.
+@propertyWrapper
+public final class Atomic<Value> {
+
+    private var value: Value
+    private let lock: Lock = PThreadRWLock()
+
+    public init(wrappedValue value: Value) {
+        self.value = value
+    }
+
+    public var wrappedValue: Value {
+        get {
+            self.lock.readLock()
+            defer { self.lock.unlock() }
+            return self.value
+        }
+        set {
+            self.lock.writeLock()
+            self.value = newValue
+            self.lock.unlock()
+        }
+    }
+
+    /// Provides an closure that will be called synchronously. This closure will be passed in the current value
+    /// and it is free to modify it. Any modifications will be saved back to the original value.
+    /// No other reads/writes will be allowed between when the closure is called and it returns.
+    public func mutate(_ closure: (inout Value) -> Void) {
+        self.lock.writeLock()
+        closure(&value)
+        self.lock.unlock()
+    }
+}

Sources/ThreadKit/Atomic.swift

@@ -0,0 +1,27 @@
+import Foundation
+
+/// Delays calls a specified amount, and consolidates all calls that come in, during that delay. Only the last one will be fired.
+public class CallDelayAndConsolidator {
+
+    private let queue: DispatchQueue
+    private var latestSetTime: CFTimeInterval?
+
+    /// The queue that all calls will be made one
+    public init(queue: DispatchQueue) {
+        self.queue = queue
+    }
+
+    /// Queues up a call to be fired after some delay. If another call is submitted to this consolidator during that delay, the delay starts anew for that
+    /// new call, and previous calls will be discarded.
+    public func performCall(with delay: TimeInterval, call: @escaping () -> Void) {
+        let setTime = CFAbsoluteTimeGetCurrent()
+        latestSetTime = setTime
+        queue.asyncAfter(deadline: .now() + delay) { [weak self] in
+            guard let self = self, let latestSetTime = self.latestSetTime, latestSetTime == setTime else {
+                return
+            }
+            self.latestSetTime = nil
+            call()
+        }
+    }
+}

Sources/ThreadKit/CallDelayAndConsolidator.swift

@@ -0,0 +1,38 @@
+import Foundation
+
+/// Wraps a closure to be called, along with the queue on which to call it.
+///
+/// It is a common pattern that asynchronous methods take in a completion closure that is called when the work is done. However it is often not enforced
+/// what queue that closure gets called on. You can add a `queue` parameter to such methods that is used just for calling the completion handler
+/// and that is probably the most correct way. However that can have other issues. That queue property can shadow the type's private queue that you meant
+/// to do all the work on, and so you block the passed in `queue` while doing that work, instead of just when calling the completion closure (had this happen).
+/// You could also just always use some arbitrary queue to call the completion. But then you need to document which queue the closure is called on.
+/// This documentation often becomes incorrect after changes down the road, and now the completion is called on a different queue then documented (had this).
+/// This type enforces that the function's caller can choose which queue to use for the completion closure, it must be called on that closure, and no other
+/// work can easily be performed on that queue.
+public struct Completion<ClosureParam> {
+
+    /// Create the completion handler. If you wish to release the `queue` and `closure` just release your reference to this Completion struct.
+    ///
+    /// - Parameters:
+    ///   - queue: The queue to use when calling `closure`
+    ///   - closure: The function to be called on `queue` at a later time.
+    public init(queue: DispatchQueue, closure: @escaping (ClosureParam) -> Void) {
+        self.queue = queue
+        self.closure = closure
+    }
+
+    /// Call this when you want to have the completion closure called.
+    ///
+    /// - Parameter value: The value to pass to the completion closure.
+    public func complete(value: ClosureParam) {
+        self.queue.async {
+            self.closure(value)
+        }
+    }
+
+    // MARK: - Private
+
+    private let queue: DispatchQueue
+    private let closure: (ClosureParam) -> Void
+}

Sources/ThreadKit/Completion.swift

@@ -0,0 +1,31 @@
+import UIKit
+
+/// The purpose of this class is to "debounce" a 'call' that happens as a result of a rapid callback
+/// But needs to be rate limited for performance reasons.
+public class Debouncer {
+
+    /// The minimum time interval before calls will execute again
+    private let bounceTime: CFTimeInterval
+
+    /// The recorded time of the last executed call
+    private var timeOfLastCall: CFTimeInterval?
+
+    public init(bounceTime: CFTimeInterval) {
+        self.bounceTime = bounceTime
+    }
+
+    /// the provided closure will be executed on the current queue if the last executed call was longer ago
+    /// than the provided bounce time.
+    public func call(_ closure: () -> Void) {
+        let currentTime = CACurrentMediaTime()
+        if let timeOfLastCall = timeOfLastCall {
+            if currentTime - timeOfLastCall > bounceTime {
+                self.timeOfLastCall = currentTime
+                closure()
+            }
+        } else {
+            self.timeOfLastCall = currentTime
+            closure()
+        }
+    }
+}

Sources/ThreadKit/Debouncer.swift

@@ -0,0 +1,63 @@
+import Foundation
+
+/// A utility that performs automatic retries of a task that can fail with a exponential backoff delay between each retry attempt
+public enum DelayedRetry {
+    private enum Constants {
+        static let retryDelayForOneRetryRemaining: TimeInterval = 4.0
+    }
+
+    /// What attempt number is this? Useful so if == 1 you know this is the first attempt and not actually a retry
+    public typealias AttemptNumber = Int
+    public typealias TaskResult = (_ success: Bool) -> Void
+    public typealias Task = (AttemptNumber, @escaping TaskResult) -> Void
+    public typealias RetryAttemptsFailed = (() -> Void)
+
+    /// Overload for testing where we can setup a faster delay so tests don't take 5+ seconds for this one test.
+    static func performTask(on queue: DispatchQueue, attemptNumber: AttemptNumber, numberOfRetries: Int, delayCalculator: @escaping (Int) -> TimeInterval,
+                            finishedAllRetryAttempts: RetryAttemptsFailed?, task: @escaping Task) {
+        queue.async {
+            task(attemptNumber, { (success) in
+                guard !success else {
+                    return
+                }
+                if numberOfRetries > 0 {
+                    let delay = delayCalculator(numberOfRetries)
+                    queue.asyncAfter(deadline: .now() + delay, execute: {
+                        performTask(on: queue, attemptNumber: attemptNumber + 1, numberOfRetries: numberOfRetries - 1, delayCalculator: delayCalculator,
+                                    finishedAllRetryAttempts: finishedAllRetryAttempts, task: task)
+                    })
+                } else if let finishedAllRetryAttempts = finishedAllRetryAttempts {
+                    queue.async(execute: finishedAllRetryAttempts)
+                }
+            })
+        }
+    }
+
+    /// Perform a task on a queue. If that task fails, this will retry running that task with an exponential growing delay before each retry
+    /// attempt.
+    ///
+    /// - Parameters:
+    ///   - queue: The queue that the `task` will be run on asynchronously
+    ///   - numberOfRetries: How many times will this `task` be rerun if you say it has failed
+    ///   - finishedAllRetryAttempts: Will be called on the `queue` only if we have retried the task `numberOfRetries` and all attempts have failed.
+    ///   - task: The task that is to be performed. Once you are finished your work inside the task, call the `TaskResult` parameter with a `true` if it
+    ///           was completed successfully (no retry needed), or `false` if the task should be retried. It is up to the caller to ensure that running the
+    ///           `task` multiple times won't cause issues. This closure is not retained beyond the minimum required to run/retry the task.
+    public static func performTask(on queue: DispatchQueue, numberOfRetries: Int, finishedAllRetryAttempts: RetryAttemptsFailed?, task: @escaping Task) {
+        performTask(on: queue, attemptNumber: 1, numberOfRetries: numberOfRetries, delayCalculator: delay(forNumberOfRemainingRetries:),
+                    finishedAllRetryAttempts: finishedAllRetryAttempts, task: task)
+    }
+
+    /// Compute the delay for the next retry based on the number of retries remaining.
+    ///
+    /// - Parameter retriesRemaining: The number of retires remaining before we stop retrying
+    /// - Returns: How long to delay before starting the next retry. The delay is the longest if this is the last retry attempt, and is cut in half for each
+    ///            additional retry remaining. So 1 retry remain = 4 second delay, 2 retry remain = 2 second delay, 3 retry = 1 second delay and so on.
+    static func delay(forNumberOfRemainingRetries retriesRemaining: Int) -> TimeInterval {
+        if retriesRemaining <= 1 {
+            return Constants.retryDelayForOneRetryRemaining
+        } else {
+            return delay(forNumberOfRemainingRetries: retriesRemaining - 1) / 2
+        }
+    }
+}