init

Author: 0xLeif

.github/workflows/CI.yml

@@ -0,0 +1,22 @@
+# This workflow will build a Swift project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-swift
+
+name: CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: macos-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Build
+      run: swift build -v
+    - name: Run tests
+      run: swift test -v

.github/workflows/docc.yml

@@ -0,0 +1,37 @@
+name: docc
+on:
+  push:
+    branches: ["main"]
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+jobs:
+  pages:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: macos-12
+    steps:
+      - name: git checkout
+        uses: actions/checkout@v3
+      - name: docbuild
+        run: |
+          xcodebuild docbuild -scheme TaskManager \
+            -derivedDataPath /tmp/docbuild \
+            -destination 'generic/platform=iOS';
+          $(xcrun --find docc) process-archive \
+            transform-for-static-hosting /tmp/docbuild/Build/Products/Debug-iphoneos/TaskManager.doccarchive \
+            --hosting-base-path TaskManager \
+            --output-path docs;
+          echo "<script>window.location.href += \"/documentation/taskmanager\"</script>" > docs/index.html;
+      - name: artifacts
+        uses: actions/upload-pages-artifact@v1
+        with:
+          path: 'docs'
+      - name: deploy
+        id: deployment
+        uses: actions/deploy-pages@v1

.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
+DerivedData/
+.swiftpm/config/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

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

@@ -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>

Package.resolved

@@ -0,0 +1,39 @@
+// swift-tools-version: 5.7
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "TaskManager",
+    platforms: [
+        .iOS(.v14),
+        .macOS(.v11),
+        .watchOS(.v7),
+        .tvOS(.v14)
+    ],
+    products: [
+        // Products define the executables and libraries a package produces, and make them visible to other packages.
+        .library(
+            name: "TaskManager",
+            targets: ["TaskManager"]
+        )
+    ],
+    dependencies: [
+        // Dependencies declare other packages that this package depends on.
+        .package(url: "https://github.com/0xOpenBytes/Cache", from: "0.1.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: "TaskManager",
+            dependencies: [
+                "Cache"
+            ]
+        ),
+        .testTarget(
+            name: "TaskManagerTests",
+            dependencies: ["TaskManager"]
+        )
+    ]
+)

Package.swift

@@ -0,0 +1,59 @@
+# TaskManager
+
+`TaskManager` is a cache for asynchronous tasks in Swift. It allows you to manage the execution of tasks with a simple API that lets you add, cancel, and wait for tasks.
+
+## Usage
+
+### Creating a TaskManager
+
+To create a `TaskManager`, simply instantiate it with a key type that conforms to `Hashable`. It is recommended to use an enum as the key type to avoid typos and ensure type safety:
+
+```swift
+enum TaskKey: Hashable {
+    case fetchUserData(userId: String)
+    case downloadFile(url: URL)
+}
+
+let taskManager = TaskManager<TaskKey>()
+```
+
+### Adding a Task
+
+To add a new task to the `TaskManager`, use the `task(key:priority:operation:)` method. The `key` parameter is the unique identifier for the task, `priority` is the priority of the task (optional), and `operation` is the async operation to be performed:
+
+```swift
+taskManager.task(key: .fetchUserData(userId: "1234"), priority: .high) {
+    // Perform async operation to fetch user data
+    return userData
+}
+```
+
+### Retrieving a Task Result
+
+To retrieve the result of a task, use the `value(for:as:)` method. The `for` parameter is the key of the task, and `as` is the type of the result you expect to receive:
+
+```swift
+let userData = try await taskManager.value(for: .fetchUserData(userId: "1234"), as: UserData.self)
+```
+
+or
+
+```swift
+let userData: UserData = try await taskManager.value(for: .fetchUserData(userId: "1234"))
+```
+
+### Canceling a Task
+
+To cancel a task, use the `cancel(key:)` method:
+
+```swift
+taskManager.cancel(key: .fetchUserData(userId: "1234"))
+```
+
+### Canceling All Tasks
+
+To cancel all tasks, use the `cancelAll()` method:
+
+```swift
+taskManager.cancelAll()
+```

README.md

@@ -0,0 +1,84 @@
+import c
+import Cache
+
+/// A `TaskManager` is a cache for asynchronous tasks.
+open class TaskManager<Key: Hashable>: Cache<Key, Task<Sendable, Error>> {
+    /// Initializes a new instance of `TaskManager`.
+    ///
+    /// - Parameter initialValues: A dictionary of initial key-value pairs to be added to the cache.
+    public required init(initialValues: [Key: Value] = [:]) {
+        super.init(initialValues: initialValues)
+    }
+
+    deinit {
+        cancelAll()
+    }
+
+    /// Cancels a task for a given key.
+    ///
+    /// - Parameter key: The key for the task to be canceled.
+    open func cancel(key: Key) {
+        get(key)?.cancel()
+        remove(key)
+    }
+
+    /// Cancels all tasks in the cache.
+    open func cancelAll() {
+        let allTasks = allValues
+
+        allTasks.forEach { managedTask in
+            cancel(key: managedTask.key)
+        }
+    }
+
+    /// Adds a new task to the cache for a given key.
+    ///
+    /// - Parameters:
+    ///   - key: The key for the new task.
+    ///   - priority: The priority of the task. Default value is `nil`.
+    ///   - operation: The operation to be performed by the task.
+    open func task(
+        key: Key,
+        priority: TaskPriority? = nil,
+        operation: @escaping () async throws -> Sendable
+    ) {
+        cancel(key: key)
+
+        let managedTask = Task(priority: priority) {
+            try await operation()
+        }
+
+        set(value: managedTask, forKey: key)
+    }
+
+    /// Wait for the task with the given key to complete, but ignore its result.
+    ///
+    /// - Parameter key: The key of the task to wait for.
+    open func wait(for key: Key) async throws {
+        let _ = try await value(for: key, as: Sendable.self)
+    }
+
+    /// Wait for the result of the task with the given key.
+    ///
+    /// - Parameters:
+    ///  - key: The key of the task to get the result of.
+    ///  - type: The expected type of the result.
+    ///
+    /// - Returns: The result of the task, if it has completed and its result is of the expected type.
+    ///
+    /// - Throws: An `InvalidTypeError` if the task result is not of the expected type.
+    open func value<Success: Sendable>(
+        for key: Key,
+        as type: Success.Type = Success.self
+    ) async throws -> Success {
+        let managedTask = try resolve(key)
+
+        let value = try await managedTask.value
+
+        guard let success = value as? Success else {
+            throw c.InvalidTypeError(expectedType: type, actualValue: value)
+        }
+
+        return success
+    }
+}

Sources/TaskManager/TaskManager.swift

@@ -0,0 +1,38 @@
+import XCTest
+@testable import TaskManager
+
+final class TaskManagerTests: XCTestCase {
+    func testValue() async throws {
+        enum TaskKey {
+            case getPi
+        }
+
+        let taskManager = TaskManager<TaskKey>()
+
+        taskManager.task(key: .getPi) {
+            Double.pi
+        }
+
+        let result: Double = try await taskManager.value(for: .getPi)
+
+        XCTAssertEqual(result, Double.pi)
+    }
+
+    func testCancel() async throws {
+        enum TaskKey {
+            case loop
+        }
+
+        let taskManager = TaskManager<TaskKey>()
+
+        taskManager.task(key: .loop) {
+            while true { /* ... */ }
+        }
+
+        taskManager.cancel(key: .loop)
+
+        try await taskManager.wait(for: .loop)
+
+        print("Infinite Loop Task was cancelled")
+    }
+}