replace totalCount and completedCount methods with setCounts

Author: chloe-yeo

Sources/FoundationEssentials/ProgressManager/ProgressManager+Interop.swift

@@ -187,7 +187,9 @@ internal final class NSProgressBridge: Progress, @unchecked Sendable {
         self.progress = progress
         super.init(parent: nil, userInfo: nil)
 
-        managerBridge.completedCount(Int(progress.completedUnitCount))
+        managerBridge.setCounts { completed, total in
+            completed = Int(progress.completedUnitCount)
+        }
 
         let position = manager.addChild(
             child: managerBridge,
@@ -200,8 +202,10 @@ internal final class NSProgressBridge: Progress, @unchecked Sendable {
     // Overrides the _updateChild func that Foundation.Progress calls to update parent
     // so that the parent that gets updated is the ProgressManager parent
     override func _updateChild(_ child: Foundation.Progress, fraction: _NSProgressFractionTuple, portion: Int64) {
-        managerBridge.totalCount(Int(fraction.next.total))
-        managerBridge.completedCount(Int(fraction.next.completed))
+        managerBridge.setCounts { completed, total in
+            completed = Int(fraction.next.completed)
+            total = Int(fraction.next.total)
+        }
         managerBridge.markSelfDirty()
     }
 }

Sources/FoundationEssentials/ProgressManager/ProgressManager.swift

@@ -196,39 +196,29 @@ internal import _FoundationCollections
         }
     }
 
-    public func completedCount(_ count: Int) {
+    public func setCounts(_ counts: (_ completed: inout Int, _ total: inout Int?) -> Void) {
         _$observationRegistrar.withMutation(of: self, keyPath: \.fractionCompleted) {
             _$observationRegistrar.withMutation(of: self, keyPath: \.completedCount) {
-                let parents: [ParentState]? = state.withLock { state in
-                    guard state.selfFraction.completed != count else {
-                        return nil
+                _$observationRegistrar.withMutation(of: self, keyPath: \.totalCount) {
+                    let parents: [ParentState]? = state.withLock { state in
+                        var completed = state.selfFraction.completed
+                        var total = state.selfFraction.total
+                        
+                        counts(&completed, &total)
+                        
+                        guard state.selfFraction.completed != completed || state.selfFraction.total != total else {
+                            return nil
+                        }
+                        
+                        state.selfFraction.completed = completed
+                        state.selfFraction.total = total
+                        
+                        return state.parents
                     }
 
-                    state.completedCount(count)
-                    
-                    return state.parents
-                }
-                if let parents = parents {
-                    markSelfDirty(parents: parents)
-                }
-            }
-        }
-    }
-    
-    public func totalCount(_ count: Int?) {
-        _$observationRegistrar.withMutation(of: self, keyPath: \.fractionCompleted) {
-            _$observationRegistrar.withMutation(of: self, keyPath: \.totalCount) {
-                let parents: [ParentState]? = state.withLock { state in
-                    guard state.selfFraction.total != count else {
-                        return nil
+                    if let parents = parents {
+                        markSelfDirty(parents: parents)
                     }
-                    
-                    state.totalCount(count)
-                    
-                    return state.parents
-                }
-                if let parents = parents {
-                    markSelfDirty(parents: parents)
                 }
             }
         }

Tests/FoundationEssentialsTests/ProgressManager/ProgressManagerTests.swift

@@ -69,15 +69,19 @@ extension Tag {
         #expect(overall.fractionCompleted == 0.5)
         #expect(overall.isIndeterminate == false)
 
-        overall.totalCount(nil)
+        overall.setCounts { _, total in
+            total = nil
+        }
         overall.complete(count: 1)
         #expect(overall.completedCount == 6)
         #expect(overall.totalCount == nil)
         #expect(overall.fractionCompleted == 0.0)
         #expect(overall.isIndeterminate == true)
         #expect(overall.isFinished == false)
 
-        overall.totalCount(12)
+        overall.setCounts { _, total in
+            total = 12
+        }
         overall.complete(count: 2)
         #expect(overall.completedCount == 8)
         #expect(overall.totalCount == 12)
@@ -110,7 +114,9 @@ extension Tag {
         #expect(overall.isIndeterminate == true)
         #expect(overall.isFinished == false)
 
-        overall.totalCount(5)
+        overall.setCounts { _, total in
+            total = 5
+        }
         #expect(overall.completedCount == 2)
         #expect(overall.totalCount == 5)
         #expect(overall.fractionCompleted == 0.4)
@@ -142,13 +148,17 @@ extension Tag {
         #expect(overall.fractionCompleted == 0.5)
         #expect(childManager.isIndeterminate == false)
 
-        childManager.totalCount(nil)
+        childManager.setCounts { _, total in
+            total = nil
+        }
 
         #expect(overall.fractionCompleted == 0.0)
         #expect(childManager.isIndeterminate == true)
         #expect(childManager.completedCount == 2)
 
-        childManager.totalCount(5)
+        childManager.setCounts { _, total in
+            total = 5
+        }
         childManager.complete(count: 2)
 
         #expect(overall.fractionCompleted == 0.8)
@@ -173,7 +183,9 @@ extension Tag {
         let manager = ProgressManager(totalCount: nil)
         #expect(manager.isIndeterminate == true)
 
-        manager.totalCount(10)
+        manager.setCounts { _, total in
+            total = 10
+        }
         #expect(manager.isIndeterminate == false)
         #expect(manager.totalCount == 10)
 
@@ -631,7 +643,9 @@ extension Tag {
             // Task 3: Change to determinate after a delay
             group.addTask {
                 try? await Task.sleep(nanoseconds: 1_000_000)
-                manager.totalCount(20)
+                manager.setCounts { _, total in
+                    total = 20
+                }
 
                 for _ in 1...30 {
                     let _ = manager.fractionCompleted

Tests/FoundationEssentialsTests/ProgressManager/ProgressReporterTests.swift

@@ -73,7 +73,9 @@ import Testing
         overall.assign(count: 20, to: child2.reporter)
         child2.complete(count: 20)
 
-        overall.totalCount(30)
+        overall.setCounts { _, total in
+            total = 30
+        }
         #expect(overall.completedCount == 20)
         #expect(overall.fractionCompleted == Double(25) / Double(30))
 
@@ -94,7 +96,9 @@ import Testing
 
         #expect(reporter2.fractionCompleted == 0.5)
 
-        overall.totalCount(30)
+        overall.setCounts { _, total in
+            total = 30
+        }
 
         #expect(overall.totalCount == 30)
         #expect(overall.fractionCompleted == 0.5)