From b7b097f49fe9d67d3df3d57c66f357738c4734e3 Mon Sep 17 00:00:00 2001 From: swiftty <62803132+swiftty@users.noreply.github.com> Date: Sat, 4 Jan 2025 05:55:56 +0900 Subject: [PATCH] Use nonisolated --- Sources/DataCacheKit/Cache.swift | 29 +++++++++++++++++--- Sources/DataCacheKit/Caching.swift | 6 ++-- Sources/DataCacheKit/DiskCache.swift | 28 +++++++++++++++++-- Sources/DataCacheKit/MemoryCache.swift | 27 ++++++++++++++++-- Tests/DataCacheKitTests/DiskCacheTests.swift | 22 +++++++-------- 5 files changed, 88 insertions(+), 24 deletions(-) diff --git a/Sources/DataCacheKit/Cache.swift b/Sources/DataCacheKit/Cache.swift index 4ee0cbd..829bef2 100644 --- a/Sources/DataCacheKit/Cache.swift +++ b/Sources/DataCacheKit/Cache.swift @@ -53,12 +53,19 @@ public actor Cache: Caching return try decoder.decode(Value.self, from: data) }() - await onMemery.store(value, for: key) + await onMemery.store(value, for: key).value return value } @discardableResult - public func store(_ value: Value, for key: Key) -> Task { + public nonisolated func store(_ value: Value, for key: Key) -> Task { + return Task { + let task = await _store(value, for: key) + await task.value + } + } + + private func _store(_ value: Value, for key: Key) -> Task { queueingTask.enqueueAndReplacing { [weak self] in guard let self else { return } async let memory: Void = await onMemery.store(value, for: key).value @@ -70,7 +77,14 @@ public actor Cache: Caching } @discardableResult - public func remove(for key: Key) -> Task { + public nonisolated func remove(for key: Key) -> Task { + return Task { + let task = await _remove(for: key) + await task.value + } + } + + private func _remove(for key: Key) -> Task { queueingTask.enqueueAndReplacing { [weak self] in guard let self else { return } async let memory: Void = await onMemery.remove(for: key).value @@ -82,7 +96,14 @@ public actor Cache: Caching } @discardableResult - public func removeAll() -> Task { + public nonisolated func removeAll() -> Task { + return Task { + let task = await _removeAll() + await task.value + } + } + + private func _removeAll() -> Task { queueingTask.enqueueAndReplacing { [weak self] in guard let self else { return } async let memory: Void = await onMemery.removeAll().value diff --git a/Sources/DataCacheKit/Caching.swift b/Sources/DataCacheKit/Caching.swift index f6b9ea4..6ba64b8 100644 --- a/Sources/DataCacheKit/Caching.swift +++ b/Sources/DataCacheKit/Caching.swift @@ -9,11 +9,11 @@ public protocol Caching: Actor { func value(for key: Key) async throws -> Value? @discardableResult - func store(_ value: Value, for key: Key) -> Task + nonisolated func store(_ value: Value, for key: Key) -> Task @discardableResult - func remove(for key: Key) -> Task + nonisolated func remove(for key: Key) -> Task @discardableResult - func removeAll() -> Task + nonisolated func removeAll() -> Task } diff --git a/Sources/DataCacheKit/DiskCache.swift b/Sources/DataCacheKit/DiskCache.swift index 6eaad88..0696581 100644 --- a/Sources/DataCacheKit/DiskCache.swift +++ b/Sources/DataCacheKit/DiskCache.swift @@ -117,8 +117,16 @@ public actor DiskCache: Caching, @unchecked Sendable { return try await task.value } + @discardableResult - public func store(_ data: Data, for key: Key) -> Task { + public nonisolated func store(_ value: Value, for key: Key) -> Task { + return Task { + let task = await _store(value, for: key) + await task.value + } + } + + private func _store(_ data: Data, for key: Key) -> Task { queueingTask.enqueueAndReplacing { [weak self] in guard let self else { return } await _storeData(data, for: key) @@ -126,7 +134,14 @@ public actor DiskCache: Caching, @unchecked Sendable { } @discardableResult - public func remove(for key: Key) -> Task { + public nonisolated func remove(for key: Key) -> Task { + return Task { + let task = await _remove(for: key) + await task.value + } + } + + private func _remove(for key: Key) -> Task { queueingTask.enqueueAndReplacing { [weak self] in guard let self else { return } await _removeData(for: key) @@ -134,7 +149,14 @@ public actor DiskCache: Caching, @unchecked Sendable { } @discardableResult - public func removeAll() -> Task { + public nonisolated func removeAll() -> Task { + return Task { + let task = await _removeAll() + await task.value + } + } + + private func _removeAll() -> Task { queueingTask.enqueueAndReplacing { [weak self] in guard let self else { return } await _removeDataAll() diff --git a/Sources/DataCacheKit/MemoryCache.swift b/Sources/DataCacheKit/MemoryCache.swift index bb8d9af..3303462 100644 --- a/Sources/DataCacheKit/MemoryCache.swift +++ b/Sources/DataCacheKit/MemoryCache.swift @@ -29,7 +29,14 @@ public actor MemoryCache: Caching { } @discardableResult - public func store(_ value: Value, for key: Key) -> Task { + public nonisolated func store(_ value: Value, for key: Key) -> Task { + return Task { + let task = await _store(value, for: key) + await task.value + } + } + + private func _store(_ value: Value, for key: Key) -> Task { queueingTask.enqueueAndReplacing { [weak self] in guard let self else { return } lruCache.setValue(value, forKey: key, cost: (value as? Data)?.count ?? 0) @@ -37,7 +44,14 @@ public actor MemoryCache: Caching { } @discardableResult - public func remove(for key: Key) -> Task { + public nonisolated func remove(for key: Key) -> Task { + return Task { + let task = await _remove(for: key) + await task.value + } + } + + private func _remove(for key: Key) -> Task { queueingTask.enqueueAndReplacing { [weak self] in guard let self else { return } lruCache.removeValue(forKey: key) @@ -45,7 +59,14 @@ public actor MemoryCache: Caching { } @discardableResult - public func removeAll() -> Task { + public nonisolated func removeAll() -> Task { + return Task { + let task = await _removeAll() + await task.value + } + } + + private func _removeAll() -> Task { queueingTask.enqueueAndReplacing { [weak self] in guard let self else { return } lruCache.removeAllValues() diff --git a/Tests/DataCacheKitTests/DiskCacheTests.swift b/Tests/DataCacheKitTests/DiskCacheTests.swift index 7b7b825..43f9b6b 100644 --- a/Tests/DataCacheKitTests/DiskCacheTests.swift +++ b/Tests/DataCacheKitTests/DiskCacheTests.swift @@ -43,7 +43,7 @@ final class DiskCacheTests { let clock = ManualClock() let cache = DiskCache(options: cacheOptions(), clock: clock, logger: .init(.default)) - await cache.store(Data(), for: "empty") + cache.store(Data(), for: "empty") try await yield(until: await cache.isFlushScheduled) @@ -81,8 +81,8 @@ final class DiskCacheTests { let clock = ManualClock() let cache = DiskCache(options: cacheOptions(), clock: clock, logger: .init(.default)) - await cache.store(Data([1]), for: "item0") - await cache.store(Data([1, 2]), for: "item1") + cache.store(Data([1]), for: "item0") + cache.store(Data([1, 2]), for: "item1") try await yield(until: await cache.isFlushScheduled) @@ -104,9 +104,9 @@ final class DiskCacheTests { let clock = ManualClock() let cache = DiskCache(options: cacheOptions(), clock: clock, logger: .init(.default)) - await cache.store(Data([1]), for: "item0") - await cache.store(Data([1, 2]), for: "item1") - await cache.remove(for: "item0") + cache.store(Data([1]), for: "item0") + cache.store(Data([1, 2]), for: "item1") + cache.remove(for: "item0") try await yield(until: await cache.isFlushScheduled) @@ -138,7 +138,7 @@ final class DiskCacheTests { let clock = ManualClock() let cache = DiskCache(options: cacheOptions(), clock: clock, logger: .init(.default)) - await cache.store(Data([1]), for: "item0") + cache.store(Data([1]), for: "item0") try await yield(until: await cache.isFlushScheduled) clock.advance(by: .milliseconds(1000)) @@ -153,7 +153,7 @@ final class DiskCacheTests { #expect(isEmpty) } - await cache.removeAll() + cache.removeAll() try await yield(until: await cache.isFlushScheduled) clock.advance(by: .milliseconds(1000)) @@ -181,9 +181,9 @@ final class DiskCacheTests { let clock = ManualClock() let cache = DiskCache(options: options, clock: clock) - await cache.store(Data([1]), for: "item0") - await cache.store(Data([1, 2]), for: "item1") - await cache.store(Data([1, 2, 3]), for: "item2") + cache.store(Data([1]), for: "item0") + cache.store(Data([1, 2]), for: "item1") + cache.store(Data([1, 2, 3]), for: "item2") try await yield(until: await cache.isFlushScheduled)