add withMutation to markDirty + correct some access keypaths

Author: chloe-yeo

Sources/FoundationEssentials/ProgressManager/ProgressManager+Properties+Helpers.swift

@@ -337,45 +337,57 @@ extension ProgressManager {
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.TotalFileCount.Type, at position: Int) {
-        let parents = state.withLock { state in
-            state.markChildDirty(property: property, at: position)
+        mutateObservation(of: ProgressManager.additionalPropertiesKeyPath.withLock { $0 }) {
+            let parents = state.withLock { state in
+                state.markChildDirty(property: property, at: position)
+            }
+            markSelfDirty(property: property, parents: parents)
         }
-        markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.CompletedFileCount.Type, at position: Int) {
-        let parents = state.withLock { state in
-            state.markChildDirty(property: property, at: position)
+        mutateObservation(of: ProgressManager.additionalPropertiesKeyPath.withLock { $0 }) {
+            let parents = state.withLock { state in
+                state.markChildDirty(property: property, at: position)
+            }
+            markSelfDirty(property: property, parents: parents)
         }
-        markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.TotalByteCount.Type, at position: Int) {
-        let parents = state.withLock { state in
-            state.markChildDirty(property: property, at: position)
+        mutateObservation(of: ProgressManager.additionalPropertiesKeyPath.withLock { $0 }) {
+            let parents = state.withLock { state in
+                state.markChildDirty(property: property, at: position)
+            }
+            markSelfDirty(property: property, parents: parents)
         }
-        markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.CompletedByteCount.Type, at position: Int) {
-        let parents = state.withLock { state in
-            state.markChildDirty(property: property, at: position)
+        mutateObservation(of: ProgressManager.additionalPropertiesKeyPath.withLock { $0 }) {
+            let parents = state.withLock { state in
+                state.markChildDirty(property: property, at: position)
+            }
+            markSelfDirty(property: property, parents: parents)
         }
-        markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.Throughput.Type, at position: Int) {
-        let parents = state.withLock { state in
-            state.markChildDirty(property: property, at: position)
+        mutateObservation(of: ProgressManager.additionalPropertiesKeyPath.withLock { $0 }) {
+            let parents = state.withLock { state in
+                state.markChildDirty(property: property, at: position)
+            }
+            markSelfDirty(property: property, parents: parents)
         }
-        markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.EstimatedTimeRemaining.Type, at position: Int) {
-        let parents = state.withLock { state in
-            state.markChildDirty(property: property, at: position)
+        mutateObservation(of: ProgressManager.additionalPropertiesKeyPath.withLock { $0 }) {
+            let parents = state.withLock { state in
+                state.markChildDirty(property: property, at: position)
+            }
+            markSelfDirty(property: property, parents: parents)
         }
-        markSelfDirty(property: property, parents: parents)
     }
 
     //MARK: Method to preserve values of properties upon deinit

Sources/FoundationEssentials/ProgressManager/ProgressManager.swift

@@ -50,7 +50,8 @@ internal import _FoundationCollections
     /// This takes into account the fraction completed in its children instances if children are present.
     /// If `self` is indeterminate, the value will be 0.0.
     public var fractionCompleted: Double {
-        _$observationRegistrar.access(self, keyPath: \.fractionCompleted)
+        _$observationRegistrar.access(self, keyPath: \.totalCount)
+        _$observationRegistrar.access(self, keyPath: \.completedCount)
         return state.withLock { state in
             state.getFractionCompleted()
         }
@@ -59,7 +60,7 @@ internal import _FoundationCollections
     /// The state of initialization of `totalCount`.
     /// If `totalCount` is `nil`, the value will be `true`.
     public var isIndeterminate: Bool {
-        _$observationRegistrar.access(self, keyPath: \.isIndeterminate)
+        _$observationRegistrar.access(self, keyPath: \.totalCount)
         return state.withLock { state in
             state.getIsIndeterminate()
         }
@@ -68,7 +69,8 @@ internal import _FoundationCollections
     /// The state of completion of work.
     /// If `completedCount` >= `totalCount`, the value will be `true`.
     public var isFinished: Bool {
-        _$observationRegistrar.access(self, keyPath: \.isFinished)
+        _$observationRegistrar.access(self, keyPath: \.totalCount)
+        _$observationRegistrar.access(self, keyPath: \.completedCount)
         return state.withLock { state in
             state.getIsFinished()
         }
@@ -178,52 +180,48 @@ internal import _FoundationCollections
     /// Increases `completedCount` by `count`.
     /// - Parameter count: Units of work.
     public func complete(count: Int) {
-        _$observationRegistrar.withMutation(of: self, keyPath: \.fractionCompleted) {
-            _$observationRegistrar.withMutation(of: self, keyPath: \.completedCount) {
+        _$observationRegistrar.withMutation(of: self, keyPath: \.completedCount) {
+            let parents: [ParentState]? = state.withLock { state in
+                guard state.selfFraction.completed != (state.selfFraction.completed + count) else {
+                    return nil
+                }
+                
+                state.complete(by: count)
+                
+                return state.parents
+            }
+            if let parents = parents {
+                markSelfDirty(parents: parents)
+            }
+        }
+    }
+    
+    public func setCounts(_ counts: (_ completed: inout Int, _ total: inout Int?) -> Void) {
+        _$observationRegistrar.withMutation(of: self, keyPath: \.completedCount) {
+            _$observationRegistrar.withMutation(of: self, keyPath: \.totalCount) {
                 let parents: [ParentState]? = state.withLock { state in
-                    guard state.selfFraction.completed != (state.selfFraction.completed + count) else {
+                    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.complete(by: count)
+                    state.selfFraction.completed = completed
+                    state.selfFraction.total = total
 
                     return state.parents
                 }
+                
                 if let parents = parents {
                     markSelfDirty(parents: parents)
                 }
             }
         }
     }
 
-    public func setCounts(_ counts: (_ completed: inout Int, _ total: inout Int?) -> Void) {
-        _$observationRegistrar.withMutation(of: self, keyPath: \.fractionCompleted) {
-            _$observationRegistrar.withMutation(of: self, keyPath: \.completedCount) {
-                _$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
-                    }
-                    
-                    if let parents = parents {
-                        markSelfDirty(parents: parents)
-                    }
-                }
-            }
-        }
-    }
-    
     // MARK: Internal Observation Support for Extensions
 
     /// Provides access to the observation registrar for use in extensions.
@@ -242,7 +240,6 @@ internal import _FoundationCollections
     internal func getProgressFraction() -> ProgressFraction {
         return state.withLock { state in
             return state.selfFraction
-            
         }
     }
 
@@ -263,11 +260,13 @@ internal import _FoundationCollections
     }
 
     private func markChildDirty(at position: Int) {
-        let parents: [ParentState]? = state.withLock { state in
-            state.markChildDirty(at: position)
-        }
-        if let parents = parents {
-            markSelfDirty(parents: parents)
+        _$observationRegistrar.withMutation(of: self, keyPath: \.completedCount) {
+            let parents: [ParentState]? = state.withLock { state in
+                state.markChildDirty(at: position)
+            }
+            if let parents = parents {
+                markSelfDirty(parents: parents)
+            }
         }
     }