rename helper methods to use update instead of updated

chloe-yeo · chloe-yeo · commit 554ff02a145d · 2025-11-04T15:23:26.000-08:00
diff --git a/Sources/FoundationEssentials/ProgressManager/ProgressManager+Properties+Accessors.swift b/Sources/FoundationEssentials/ProgressManager/ProgressManager+Properties+Accessors.swift
@@ -392,19 +392,19 @@ extension ProgressManager {
         if P.self == ProgressManager.Properties.TotalFileCount.self {
             self.access(keyPath: \.totalFileCount)
             self.access(keyPath: \.totalFileCountSummary)
-            let updatedFileCount = updatedFileCount(type: .total)
+            let updatedFileCount = updateFileCount(type: .total)
             self.didSet(keyPath: \.totalFileCountSummary)
             return updatedFileCount
         } else if P.self == ProgressManager.Properties.CompletedFileCount.self {
             self.access(keyPath: \.completedFileCount)
             self.access(keyPath: \.completedFileCountSummary)
-            let updatedFileCount = updatedFileCount(type: .completed)
+            let updatedFileCount = updateFileCount(type: .completed)
             self.didSet(keyPath: \.completedFileCountSummary)
             return updatedFileCount
         } else {
             self.access(keyPath: \.customPropertiesInt)
             self.access(keyPath: \.customPropertiesIntSummary)
-            let updatedResult = updatedIntSummary(property: MetatypeWrapper(P.self))
+            let updatedResult = updateIntSummary(property: MetatypeWrapper(P.self))
             self.didSet(keyPath: \.customPropertiesIntSummary)
             return updatedResult
         }
@@ -422,19 +422,19 @@ extension ProgressManager {
         if P.self == ProgressManager.Properties.TotalByteCount.self {
             self.access(keyPath: \.totalByteCount)
             self.access(keyPath: \.totalByteCountSummary)
-            let updatedByteCount = updatedByteCount(type: .total)
+            let updatedByteCount = updateByteCount(type: .total)
             self.didSet(keyPath: \.totalByteCountSummary)
             return updatedByteCount
         } else if P.self == ProgressManager.Properties.CompletedByteCount.self {
             self.access(keyPath: \.completedByteCount)
             self.access(keyPath: \.completedByteCountSummary)
-            let updatedByteCount = updatedByteCount(type: .completed)
+            let updatedByteCount = updateByteCount(type: .completed)
             self.didSet(keyPath: \.completedByteCountSummary)
             return updatedByteCount
         } else {
             self.access(keyPath: \.customPropertiesUInt64)
             self.access(keyPath: \.customPropertiesUInt64Summary)
-            let updatedResult = updatedUInt64Summary(property: MetatypeWrapper(P.self))
+            let updatedResult = updateUInt64Summary(property: MetatypeWrapper(P.self))
             self.didSet(keyPath: \.customPropertiesUInt64Summary)
             return updatedResult
         }
@@ -451,7 +451,7 @@ extension ProgressManager {
     public func summary<P: Property>(of property: KeyPath<ProgressManager.Properties, P.Type>) -> P.Summary where P.Value == Double, P.Summary == Double {
         self.access(keyPath: \.customPropertiesDouble)
         self.access(keyPath: \.customPropertiesDoubleSummary)
-        let updatedResult = updatedDoubleSummary(property: MetatypeWrapper(P.self))
+        let updatedResult = updateDoubleSummary(property: MetatypeWrapper(P.self))
         self.didSet(keyPath: \.customPropertiesDoubleSummary)
         return updatedResult
     }
@@ -467,7 +467,7 @@ extension ProgressManager {
     public func summary<P: Property>(of property: KeyPath<ProgressManager.Properties, P.Type>) -> P.Summary where P.Value == String?, P.Summary == [String?] {
         self.access(keyPath: \.customPropertiesString)
         self.access(keyPath: \.customPropertiesStringSummary)
-        let updatedResult = updatedStringSummary(property: MetatypeWrapper(P.self))
+        let updatedResult = updateStringSummary(property: MetatypeWrapper(P.self))
         self.didSet(keyPath: \.customPropertiesStringSummary)
         return updatedResult
     }
@@ -483,7 +483,7 @@ extension ProgressManager {
     public func summary<P: Property>(of property: KeyPath<ProgressManager.Properties, P.Type>) -> P.Summary where P.Value == URL?, P.Summary == [URL?] {
         self.access(keyPath: \.customPropertiesURL)
         self.access(keyPath: \.customPropertiesURLSummary)
-        let updatedResult = updatedURLSummary(property: MetatypeWrapper(P.self))
+        let updatedResult = updateURLSummary(property: MetatypeWrapper(P.self))
         self.didSet(keyPath: \.customPropertiesURLSummary)
         return updatedResult
     }
@@ -500,13 +500,13 @@ extension ProgressManager {
         if P.self == ProgressManager.Properties.Throughput.self {
             self.access(keyPath: \.throughput)
             self.access(keyPath: \.throughputSummary)
-            let updatedThroughput = updatedThroughput()
+            let updatedThroughput = updateThroughput()
             self.didSet(keyPath: \.throughputSummary)
             return updatedThroughput
         } else {
             self.access(keyPath: \.customPropertiesUInt64Array)
             self.access(keyPath: \.customPropertiesUInt64ArraySummary)
-            let updatedResult = updatedUInt64ArraySummary(property: MetatypeWrapper(P.self))
+            let updatedResult = updateUInt64ArraySummary(property: MetatypeWrapper(P.self))
             self.didSet(keyPath: \.customPropertiesUInt64ArraySummary)
             return updatedResult
         }
@@ -524,13 +524,13 @@ extension ProgressManager {
         if P.self == ProgressManager.Properties.EstimatedTimeRemaining.self {
             self.access(keyPath: \.estimatedTimeRemaining)
             self.access(keyPath: \.estimatedTimeRemainingSummary)
-            let updatedTimeRemaining = updatedEstimatedTimeRemaining()
+            let updatedTimeRemaining = updateEstimatedTimeRemaining()
             self.didSet(keyPath: \.estimatedTimeRemainingSummary)
             return updatedTimeRemaining
         } else {
             self.access(keyPath: \.customPropertiesDuration)
             self.access(keyPath: \.customPropertiesDurationSummary)
-            let updatedResult = updatedDurationSummary(property: MetatypeWrapper(P.self))
+            let updatedResult = updateDurationSummary(property: MetatypeWrapper(P.self))
             self.didSet(keyPath: \.customPropertiesDurationSummary)
             return updatedResult
         }
diff --git a/Sources/FoundationEssentials/ProgressManager/ProgressManager+Properties+Helpers.swift b/Sources/FoundationEssentials/ProgressManager/ProgressManager+Properties+Helpers.swift
@@ -23,15 +23,15 @@ extension ProgressManager {
     }
     
     //MARK: Helper Methods for Updating Dirty Path
-    internal func updatedIntSummary(property: MetatypeWrapper<Int, Int>) -> Int {
+    internal func updateIntSummary(property: MetatypeWrapper<Int, Int>) -> Int {
         // Get information about dirty children and summaries of non-dirty children
         let updateInfo = state.withLock { state in
             state.getIntSummaryUpdateInfo(property: property)
         }
         
         // Get updated summary for each dirty child
         let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
-            State.IntSummaryUpdate(index: index, updatedSummary: child.updatedIntSummary(property: property))
+            State.IntSummaryUpdate(index: index, updatedSummary: child.updateIntSummary(property: property))
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
@@ -40,15 +40,15 @@ extension ProgressManager {
         }
     }
     
-    internal func updatedUInt64Summary(property: MetatypeWrapper<UInt64, UInt64>) -> UInt64 {
+    internal func updateUInt64Summary(property: MetatypeWrapper<UInt64, UInt64>) -> UInt64 {
         // Get information about dirty children and summaries of non-dirty children
         let updateInfo = state.withLock { state in
             state.getUInt64SummaryUpdateInfo(property: property)
         }
         
         // Get updated summary for each dirty child
         let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
-            State.UInt64SummaryUpdate(index: index, updatedSummary: child.updatedUInt64Summary(property: property))
+            State.UInt64SummaryUpdate(index: index, updatedSummary: child.updateUInt64Summary(property: property))
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
@@ -57,15 +57,15 @@ extension ProgressManager {
         }
     }
     
-    internal func updatedDoubleSummary(property: MetatypeWrapper<Double, Double>) -> Double {
+    internal func updateDoubleSummary(property: MetatypeWrapper<Double, Double>) -> Double {
         // Get information about dirty children and summaries of non-dirty children
         let updateInfo = state.withLock { state in
             state.getDoubleSummaryUpdateInfo(property: property)
         }
         
         // Get updated summary for each dirty child
         let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
-            State.DoubleSummaryUpdate(index: index, updatedSummary: child.updatedDoubleSummary(property: property))
+            State.DoubleSummaryUpdate(index: index, updatedSummary: child.updateDoubleSummary(property: property))
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
@@ -74,15 +74,15 @@ extension ProgressManager {
         }
     }
     
-    internal func updatedStringSummary(property: MetatypeWrapper<String?, [String?]>) -> [String?] {
+    internal func updateStringSummary(property: MetatypeWrapper<String?, [String?]>) -> [String?] {
         // Get information about dirty children and summaries of non-dirty children
         let updateInfo = state.withLock { state in
             state.getStringSummaryUpdateInfo(property: property)
         }
         
         // Get updated summary for each dirty child
         let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
-            State.StringSummaryUpdate(index: index, updatedSummary: child.updatedStringSummary(property: property))
+            State.StringSummaryUpdate(index: index, updatedSummary: child.updateStringSummary(property: property))
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
@@ -91,15 +91,15 @@ extension ProgressManager {
         }
     }
     
-    internal func updatedURLSummary(property: MetatypeWrapper<URL?, [URL?]>) -> [URL?] {
+    internal func updateURLSummary(property: MetatypeWrapper<URL?, [URL?]>) -> [URL?] {
         // Get information about dirty children and summaries of non-dirty children
         let updateInfo = state.withLock { state in
             state.getURLSummaryUpdateInfo(property: property)
         }
         
         // Get updated summary for each dirty child
         let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
-            State.URLSummaryUpdate(index: index, updatedSummary: child.updatedURLSummary(property: property))
+            State.URLSummaryUpdate(index: index, updatedSummary: child.updateURLSummary(property: property))
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
@@ -108,15 +108,15 @@ extension ProgressManager {
         }
     }
     
-    internal func updatedUInt64ArraySummary(property: MetatypeWrapper<UInt64, [UInt64]>) -> [UInt64] {
+    internal func updateUInt64ArraySummary(property: MetatypeWrapper<UInt64, [UInt64]>) -> [UInt64] {
         // Get information about dirty children and summaries of non-dirty children
         let updateInfo = state.withLock { state in
             state.getUInt64ArraySummaryUpdateInfo(property: property)
         }
         
         // Get updated summary for each dirty child
         let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
-            State.UInt64ArraySummaryUpdate(index: index, updatedSummary: child.updatedUInt64ArraySummary(property: property))
+            State.UInt64ArraySummaryUpdate(index: index, updatedSummary: child.updateUInt64ArraySummary(property: property))
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
@@ -125,15 +125,15 @@ extension ProgressManager {
         }
     }
     
-    internal func updatedDurationSummary(property: MetatypeWrapper<Duration, Duration>) -> Duration {
+    internal func updateDurationSummary(property: MetatypeWrapper<Duration, Duration>) -> Duration {
         // Get information about dirty children and summaries of non-dirty children
         let updateInfo = state.withLock { state in
             state.getDurationSummaryUpdateInfo(property: property)
         }
         
         // Get updated summary for each dirty child
         let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
-            State.DurationSummaryUpdate(index: index, updatedSummary: child.updatedDurationSummary(property: property))
+            State.DurationSummaryUpdate(index: index, updatedSummary: child.updateDurationSummary(property: property))
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
@@ -142,15 +142,15 @@ extension ProgressManager {
         }
     }
     
-    internal func updatedFileCount(type: CountType) -> Int {
+    internal func updateFileCount(type: CountType) -> Int {
         // Get information about dirty children and summaries of non-dirty children
         let updateInfo = state.withLock { state in
             state.getFileCountUpdateInfo(type: type)
         }
         
         // Get updated summary for each dirty child
         let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
-            State.FileCountUpdate(index: index, updatedSummary: child.updatedFileCount(type: type))
+            State.FileCountUpdate(index: index, updatedSummary: child.updateFileCount(type: type))
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
@@ -159,15 +159,15 @@ extension ProgressManager {
         }
     }
     
-    internal func updatedByteCount(type: CountType) -> UInt64 {
+    internal func updateByteCount(type: CountType) -> UInt64 {
         // Get information about dirty children and summaries of non-dirty children
         let updateInfo = state.withLock { state in
             state.getByteCountUpdateInfo(type: type)
         }
         
         // Get updated summary for each dirty child
         let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
-            State.ByteCountUpdate(index: index, updatedSummary: child.updatedByteCount(type: type))
+            State.ByteCountUpdate(index: index, updatedSummary: child.updateByteCount(type: type))
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
@@ -176,32 +176,32 @@ extension ProgressManager {
         }
     }
     
-    internal func updatedThroughput() -> [UInt64] {
+    internal func updateThroughput() -> [UInt64] {
         // Get information about dirty children and summaries of non-dirty children
         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.updatedThroughput())
+            State.ThroughputUpdate(index: index, updatedSummary: child.updateThroughput())
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
         return state.withLock { state in
-            state.updatedThroughput(updateInfo, updatedSummaries)
+            state.updateThroughput(updateInfo, updatedSummaries)
         }
     }
     
-    internal func updatedEstimatedTimeRemaining() -> Duration {
+    internal func updateEstimatedTimeRemaining() -> Duration {
         // Get information about dirty children and summaries of non-dirty children
         let updateInfo = state.withLock { state in
             state.getEstimatedTimeRemainingUpdateInfo()
         }
         
         // Get updated summary for each dirty child
         let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in
-            State.EstimatedTimeRemainingUpdate(index: index, updatedSummary: child.updatedEstimatedTimeRemaining())
+            State.EstimatedTimeRemainingUpdate(index: index, updatedSummary: child.updateEstimatedTimeRemaining())
         }
         
         // Consolidate updated summaries of dirty children and summaries of non-dirty children
diff --git a/Sources/FoundationEssentials/ProgressManager/ProgressManager+State.swift b/Sources/FoundationEssentials/ProgressManager/ProgressManager+State.swift
@@ -1320,7 +1320,7 @@ extension ProgressManager {
             )
         }
         
-        internal mutating func updatedThroughput(_ updateInfo: ThroughputUpdateInfo, _ childUpdates: [ThroughputUpdate]) -> [UInt64] {
+        internal mutating func updateThroughput(_ updateInfo: ThroughputUpdateInfo, _ childUpdates: [ThroughputUpdate]) -> [UInt64] {
             var value = updateInfo.currentSummary
             
             // Apply updates from children that were dirty

Original file line number	Diff line number	Diff line change
`@@ -23,15 +23,15 @@ extension ProgressManager {`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`//MARK: Helper Methods for Updating Dirty Path`
`26`		`- internal func updatedIntSummary(property: MetatypeWrapper<Int, Int>) -> Int {`
	`26`	`+ internal func updateIntSummary(property: MetatypeWrapper<Int, Int>) -> Int {`
`27`	`27`	`// Get information about dirty children and summaries of non-dirty children`
`28`	`28`	`let updateInfo = state.withLock { state in`
`29`	`29`	`state.getIntSummaryUpdateInfo(property: property)`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`// Get updated summary for each dirty child`
`33`	`33`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`34`		`- State.IntSummaryUpdate(index: index, updatedSummary: child.updatedIntSummary(property: property))`
	`34`	`+ State.IntSummaryUpdate(index: index, updatedSummary: child.updateIntSummary(property: property))`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
`@@ -40,15 +40,15 @@ extension ProgressManager {`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`		`- internal func updatedUInt64Summary(property: MetatypeWrapper<UInt64, UInt64>) -> UInt64 {`
	`43`	`+ internal func updateUInt64Summary(property: MetatypeWrapper<UInt64, UInt64>) -> UInt64 {`
`44`	`44`	`// Get information about dirty children and summaries of non-dirty children`
`45`	`45`	`let updateInfo = state.withLock { state in`
`46`	`46`	`state.getUInt64SummaryUpdateInfo(property: property)`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`// Get updated summary for each dirty child`
`50`	`50`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`51`		`- State.UInt64SummaryUpdate(index: index, updatedSummary: child.updatedUInt64Summary(property: property))`
	`51`	`+ State.UInt64SummaryUpdate(index: index, updatedSummary: child.updateUInt64Summary(property: property))`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
`@@ -57,15 +57,15 @@ extension ProgressManager {`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`- internal func updatedDoubleSummary(property: MetatypeWrapper<Double, Double>) -> Double {`
	`60`	`+ internal func updateDoubleSummary(property: MetatypeWrapper<Double, Double>) -> Double {`
`61`	`61`	`// Get information about dirty children and summaries of non-dirty children`
`62`	`62`	`let updateInfo = state.withLock { state in`
`63`	`63`	`state.getDoubleSummaryUpdateInfo(property: property)`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`// Get updated summary for each dirty child`
`67`	`67`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`68`		`- State.DoubleSummaryUpdate(index: index, updatedSummary: child.updatedDoubleSummary(property: property))`
	`68`	`+ State.DoubleSummaryUpdate(index: index, updatedSummary: child.updateDoubleSummary(property: property))`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
`@@ -74,15 +74,15 @@ extension ProgressManager {`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`		`- internal func updatedStringSummary(property: MetatypeWrapper<String?, [String?]>) -> [String?] {`
	`77`	`+ internal func updateStringSummary(property: MetatypeWrapper<String?, [String?]>) -> [String?] {`
`78`	`78`	`// Get information about dirty children and summaries of non-dirty children`
`79`	`79`	`let updateInfo = state.withLock { state in`
`80`	`80`	`state.getStringSummaryUpdateInfo(property: property)`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`// Get updated summary for each dirty child`
`84`	`84`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`85`		`- State.StringSummaryUpdate(index: index, updatedSummary: child.updatedStringSummary(property: property))`
	`85`	`+ State.StringSummaryUpdate(index: index, updatedSummary: child.updateStringSummary(property: property))`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
`@@ -91,15 +91,15 @@ extension ProgressManager {`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`		`- internal func updatedURLSummary(property: MetatypeWrapper<URL?, [URL?]>) -> [URL?] {`
	`94`	`+ internal func updateURLSummary(property: MetatypeWrapper<URL?, [URL?]>) -> [URL?] {`
`95`	`95`	`// Get information about dirty children and summaries of non-dirty children`
`96`	`96`	`let updateInfo = state.withLock { state in`
`97`	`97`	`state.getURLSummaryUpdateInfo(property: property)`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`// Get updated summary for each dirty child`
`101`	`101`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`102`		`- State.URLSummaryUpdate(index: index, updatedSummary: child.updatedURLSummary(property: property))`
	`102`	`+ State.URLSummaryUpdate(index: index, updatedSummary: child.updateURLSummary(property: property))`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
`@@ -108,15 +108,15 @@ extension ProgressManager {`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`- internal func updatedUInt64ArraySummary(property: MetatypeWrapper<UInt64, [UInt64]>) -> [UInt64] {`
	`111`	`+ internal func updateUInt64ArraySummary(property: MetatypeWrapper<UInt64, [UInt64]>) -> [UInt64] {`
`112`	`112`	`// Get information about dirty children and summaries of non-dirty children`
`113`	`113`	`let updateInfo = state.withLock { state in`
`114`	`114`	`state.getUInt64ArraySummaryUpdateInfo(property: property)`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`// Get updated summary for each dirty child`
`118`	`118`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`119`		`- State.UInt64ArraySummaryUpdate(index: index, updatedSummary: child.updatedUInt64ArraySummary(property: property))`
	`119`	`+ State.UInt64ArraySummaryUpdate(index: index, updatedSummary: child.updateUInt64ArraySummary(property: property))`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
`@@ -125,15 +125,15 @@ extension ProgressManager {`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`128`		`- internal func updatedDurationSummary(property: MetatypeWrapper<Duration, Duration>) -> Duration {`
	`128`	`+ internal func updateDurationSummary(property: MetatypeWrapper<Duration, Duration>) -> Duration {`
`129`	`129`	`// Get information about dirty children and summaries of non-dirty children`
`130`	`130`	`let updateInfo = state.withLock { state in`
`131`	`131`	`state.getDurationSummaryUpdateInfo(property: property)`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`// Get updated summary for each dirty child`
`135`	`135`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`136`		`- State.DurationSummaryUpdate(index: index, updatedSummary: child.updatedDurationSummary(property: property))`
	`136`	`+ State.DurationSummaryUpdate(index: index, updatedSummary: child.updateDurationSummary(property: property))`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
`@@ -142,15 +142,15 @@ extension ProgressManager {`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`145`		`- internal func updatedFileCount(type: CountType) -> Int {`
	`145`	`+ internal func updateFileCount(type: CountType) -> Int {`
`146`	`146`	`// Get information about dirty children and summaries of non-dirty children`
`147`	`147`	`let updateInfo = state.withLock { state in`
`148`	`148`	`state.getFileCountUpdateInfo(type: type)`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`// Get updated summary for each dirty child`
`152`	`152`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`153`		`- State.FileCountUpdate(index: index, updatedSummary: child.updatedFileCount(type: type))`
	`153`	`+ State.FileCountUpdate(index: index, updatedSummary: child.updateFileCount(type: type))`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
`@@ -159,15 +159,15 @@ extension ProgressManager {`
`159`	`159`	`}`
`160`	`160`	`}`
`161`	`161`
`162`		`- internal func updatedByteCount(type: CountType) -> UInt64 {`
	`162`	`+ internal func updateByteCount(type: CountType) -> UInt64 {`
`163`	`163`	`// Get information about dirty children and summaries of non-dirty children`
`164`	`164`	`let updateInfo = state.withLock { state in`
`165`	`165`	`state.getByteCountUpdateInfo(type: type)`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`// Get updated summary for each dirty child`
`169`	`169`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`170`		`- State.ByteCountUpdate(index: index, updatedSummary: child.updatedByteCount(type: type))`
	`170`	`+ State.ByteCountUpdate(index: index, updatedSummary: child.updateByteCount(type: type))`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
`@@ -176,32 +176,32 @@ extension ProgressManager {`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`
`179`		`- internal func updatedThroughput() -> [UInt64] {`
	`179`	`+ internal func updateThroughput() -> [UInt64] {`
`180`	`180`	`// Get information about dirty children and summaries of non-dirty children`
`181`	`181`	`let updateInfo = state.withLock { state in`
`182`	`182`	`state.getThroughputUpdateInfo()`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`// Get updated summary for each dirty child`
`186`	`186`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`187`		`- State.ThroughputUpdate(index: index, updatedSummary: child.updatedThroughput())`
	`187`	`+ State.ThroughputUpdate(index: index, updatedSummary: child.updateThroughput())`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
`191`	`191`	`return state.withLock { state in`
`192`		`- state.updatedThroughput(updateInfo, updatedSummaries)`
	`192`	`+ state.updateThroughput(updateInfo, updatedSummaries)`
`193`	`193`	`}`
`194`	`194`	`}`
`195`	`195`
`196`		`- internal func updatedEstimatedTimeRemaining() -> Duration {`
	`196`	`+ internal func updateEstimatedTimeRemaining() -> Duration {`
`197`	`197`	`// Get information about dirty children and summaries of non-dirty children`
`198`	`198`	`let updateInfo = state.withLock { state in`
`199`	`199`	`state.getEstimatedTimeRemainingUpdateInfo()`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`// Get updated summary for each dirty child`
`203`	`203`	`let updatedSummaries = updateInfo.dirtyChildren.map { (index, child) in`
`204`		`- State.EstimatedTimeRemainingUpdate(index: index, updatedSummary: child.updatedEstimatedTimeRemaining())`
	`204`	`+ State.EstimatedTimeRemainingUpdate(index: index, updatedSummary: child.updateEstimatedTimeRemaining())`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`// Consolidate updated summaries of dirty children and summaries of non-dirty children`
Original file line number	Diff line number	Diff line change
`@@ -1320,7 +1320,7 @@ extension ProgressManager {`
`1320`	`1320`	`)`
`1321`	`1321`	`}`
`1322`	`1322`
`1323`		`- internal mutating func updatedThroughput(_ updateInfo: ThroughputUpdateInfo, _ childUpdates: [ThroughputUpdate]) -> [UInt64] {`
	`1323`	`+ internal mutating func updateThroughput(_ updateInfo: ThroughputUpdateInfo, _ childUpdates: [ThroughputUpdate]) -> [UInt64] {`
`1324`	`1324`	`var value = updateInfo.currentSummary`
`1325`	`1325`
`1326`	`1326`	`// Apply updates from children that were dirty`