refactor markSelfDirty methods + getUpdatedThroughput method

Author: chloe-yeo

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

@@ -363,34 +363,19 @@ extension ProgressManager {
     }
 
     internal func getUpdatedThroughput() -> [UInt64] {
+        // Collect information from state
+        let updateInfo = state.withLock { state in
+            state.getThroughputUpdateInfo()
+        }
+        
+        // Get updated summary for each dirty child
+        let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
+            State.ThroughputUpdate(index: index, updatedSummary: child.getUpdatedThroughput())
+        }
+        
+        // Consolidate updated values
         return state.withLock { state in
-            // Get self's throughput as part of summary
-            var value = ProgressManager.Properties.Throughput.defaultSummary
-            ProgressManager.Properties.Throughput.reduce(into: &value, value: state.throughput)
-            
-            guard !state.children.isEmpty else {
-                return value
-            }
-            
-            for (idx, childState) in state.children.enumerated() {
-                if childState.throughput.isDirty {
-                    // Update dirty path
-                    if let child = childState.child {
-                        let updatedSummary = child.getUpdatedThroughput()
-                        let newThroughputState = PropertyStateThroughput(value: updatedSummary, isDirty: false)
-                        state.children[idx].throughput = newThroughputState
-                        value = ProgressManager.Properties.Throughput.merge(value, updatedSummary)
-                    }
-                } else {
-                    if let _ = childState.child {
-                        // Merge non-dirty, updated value
-                        value = ProgressManager.Properties.Throughput.merge(value, childState.throughput.value)
-                    } else {
-                        value = ProgressManager.Properties.Throughput.finalSummary(value, childState.throughput.value)
-                    }
-                }
-            }
-            return value
+            state.getUpdatedThroughput(updateInfo, updatedSummaries)
         }
     }
 
@@ -518,88 +503,77 @@ extension ProgressManager {
 
     internal func markChildDirty(property: MetatypeWrapper<Int, Int>, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].childPropertiesInt[property]?.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: MetatypeWrapper<Double, Double>, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].childPropertiesDouble[property]?.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: MetatypeWrapper<String?, [String?]>, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].childPropertiesString[property]?.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: MetatypeWrapper<URL?, [URL?]>, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].childPropertiesURL[property]?.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: MetatypeWrapper<UInt64, [UInt64]>, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].childPropertiesUInt64[property]?.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.TotalFileCount.Type, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].totalFileCount.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.CompletedFileCount.Type, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].completedFileCount.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.TotalByteCount.Type, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].totalByteCount.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.CompletedByteCount.Type, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].completedByteCount.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.Throughput.Type, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].throughput.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }
 
     internal func markChildDirty(property: ProgressManager.Properties.EstimatedTimeRemaining.Type, at position: Int) {
         let parents = state.withLock { state in
-            state.children[position].estimatedTimeRemaining.isDirty = true
-            return state.parents
+            state.markChildDirty(property: property, at: position)
         }
         markSelfDirty(property: property, parents: parents)
     }

Sources/FoundationEssentials/ProgressManager/ProgressManager+State.swift

@@ -235,5 +235,135 @@ extension ProgressManager {
             }
 #endif
         }
+        
+        // MARK: Mark paths dirty
+        internal mutating func markChildDirty(at position: Int) -> [ParentState]? {
+            guard !children[position].isDirty else {
+                return nil
+            }
+            children[position].isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: MetatypeWrapper<Int, Int>, at position: Int) -> [ParentState] {
+            children[position].childPropertiesInt[property]?.isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: MetatypeWrapper<Double, Double>, at position: Int) -> [ParentState] {
+            children[position].childPropertiesDouble[property]?.isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: MetatypeWrapper<String?, [String?]>, at position: Int) -> [ParentState] {
+            children[position].childPropertiesString[property]?.isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: MetatypeWrapper<URL?, [URL?]>, at position: Int) -> [ParentState] {
+            children[position].childPropertiesURL[property]?.isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: MetatypeWrapper<UInt64, [UInt64]>, at position: Int) -> [ParentState] {
+            children[position].childPropertiesUInt64[property]?.isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: ProgressManager.Properties.TotalFileCount.Type, at position: Int) -> [ParentState] {
+            children[position].totalFileCount.isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: ProgressManager.Properties.CompletedFileCount.Type, at position: Int) -> [ParentState] {
+            children[position].completedFileCount.isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: ProgressManager.Properties.TotalByteCount.Type, at position: Int) -> [ParentState] {
+            children[position].totalByteCount.isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: ProgressManager.Properties.CompletedByteCount.Type, at position: Int) -> [ParentState] {
+            children[position].completedByteCount.isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: ProgressManager.Properties.Throughput.Type, at position: Int) -> [ParentState] {
+            children[position].throughput.isDirty = true
+            return parents
+        }
+        
+        internal mutating func markChildDirty(property: ProgressManager.Properties.EstimatedTimeRemaining.Type, at position: Int) -> [ParentState] {
+            children[position].estimatedTimeRemaining.isDirty = true
+            return parents
+        }
+        
+        // MARK: Clean up dirty paths
+        internal struct ThroughputUpdateInfo {
+            let currentSummary: [UInt64]
+            let dirtyChildren: [(index: Int, manager: ProgressManager)]
+            let nonDirtySummaries: [(index: Int, summary: [UInt64], isAlive: Bool)]
+        }
+        
+        internal struct ThroughputUpdate {
+            let index: Int
+            let updatedSummary: [UInt64]
+        }
+        
+        internal mutating func getThroughputUpdateInfo() -> ThroughputUpdateInfo {
+            var currentSummary = ProgressManager.Properties.Throughput.defaultSummary
+            ProgressManager.Properties.Throughput.reduce(into: &currentSummary, value: throughput)
+            
+            guard !children.isEmpty else {
+                return ThroughputUpdateInfo(
+                    currentSummary: currentSummary,
+                    dirtyChildren: [],
+                    nonDirtySummaries: []
+                )
+            }
+            
+            var dirtyChildren: [(index: Int, manager: ProgressManager)] = []
+            var nonDirtySummaries: [(index: Int, summary: [UInt64], isAlive: Bool)] = []
+            
+            for (idx, childState) in children.enumerated() {
+                if childState.throughput.isDirty {
+                    if let child = childState.child {
+                        dirtyChildren.append((idx, child))
+                    }
+                } else {
+                    let isAlive = childState.child != nil
+                    nonDirtySummaries.append((idx, childState.throughput.value, isAlive))
+                }
+            }
+            
+            return ThroughputUpdateInfo(
+                currentSummary: currentSummary,
+                dirtyChildren: dirtyChildren,
+                nonDirtySummaries: nonDirtySummaries
+            )
+        }
+        
+        internal mutating func getUpdatedThroughput(_ updateInfo: ThroughputUpdateInfo, _ childUpdates: [ThroughputUpdate]) -> [UInt64] {
+            var value = updateInfo.currentSummary
+            
+            // Apply updates from children that were dirty
+            for update in childUpdates {
+                children[update.index].throughput = PropertyStateThroughput(value: update.updatedSummary, isDirty: false)
+                value = ProgressManager.Properties.Throughput.merge(value, update.updatedSummary)
+            }
+            
+            // Apply values from non-dirty children
+            for (_, childSummary, isAlive) in updateInfo.nonDirtySummaries {
+                if isAlive {
+                    value = ProgressManager.Properties.Throughput.merge(value, childSummary)
+                } else {
+                    value = ProgressManager.Properties.Throughput.finalSummary(value, childSummary)
+                }
+            }
+            
+            return value
+        }
     }
 }

Sources/FoundationEssentials/ProgressManager/ProgressManager.swift

@@ -227,11 +227,7 @@ internal import _FoundationCollections
 
     private func markChildDirty(at position: Int) {
         let parents: [ParentState]? = state.withLock { state in
-            guard !state.children[position].isDirty else {
-                return nil
-            }
-            state.children[position].isDirty = true
-            return state.parents
+            state.markChildDirty(at: position)
         }
         if let parents = parents {
             markSelfDirty(parents: parents)