refactor interop-related stuff

Author: chloe-yeo

Sources/FoundationEssentials/ProgressManager/ProgressManager+Interop.swift

@@ -9,15 +9,13 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-// Keep all interop logiv here
+
 #if FOUNDATION_FRAMEWORK
 internal import _ForSwiftFoundation
+internal import Synchronization
+
 @available(FoundationPreview 6.2, *)
-//MARK: Progress Parent - ProgressManager Child Interop
-// Actual Progress Parent
-// Ghost Progress Parent
-// Ghost ProgressManager Child
-// Actual ProgressManager Child
+//MARK: Progress Parent - Subprogress / ProgressReporter Child Interop
 extension Progress {
 
     /// Returns a Subprogress which can be passed to any method that reports progress
@@ -30,28 +28,27 @@ extension Progress {
     /// - Returns: A `Subprogress` instance.
     public func makeChild(withPendingUnitCount count: Int) -> Subprogress {
 
-        // Make ghost parent & add it to actual parent's children list
-        let topProgress = Progress(totalUnitCount: 1)
-        self.addChild(topProgress, withPendingUnitCount: Int64(count))
+        // Make a ProgressManager
+        let manager = ProgressManager(totalCount: 1)
 
-        // Make ghost child
-        let bottomProgress = ProgressManager(totalCount: 1)
+        // Create a NSProgress - ProgressManager bridge for mirroring
+        let subprogressBridge = SubprogressBridge(
+            parent: self,
+            portion: Int64(count),
+            manager: manager
+        )
 
-        // Make observation instance
-        let managerObservation = _NSProgressParentSubprogressChild(
-            ghostParent: topProgress,
-            ghostChild: bottomProgress
+        // Instantiate a Subprogress with ProgressManager as parent
+        // Store bridge
+        let subprogress = Subprogress(
+            parent: manager,
+            portionOfParent: 1,
+            subprogressBridge: subprogressBridge
         )
 
-        // Make actual child with ghost child being parent
-        var subprogress = Subprogress(parent: bottomProgress, portionOfParent: 1)
-        bottomProgress.subprogress(assigningCount: 1)
-        subprogress.managerObservation = managerObservation
-        subprogress.progressParentProgressManagerChildMessenger = bottomProgress
         return subprogress
     }
 
-    
     /// Adds a ProgressReporter as a child to a Progress, which constitutes a portion of Progress's totalUnitCount.
     ///
     /// - Parameters:
@@ -61,17 +58,15 @@ extension Progress {
 
         precondition(self.isCycle(reporter: reporter) == false, "Creating a cycle is not allowed.")
 
-        // Make intermediary & add it to NSProgress parent's children list
-        let ghostProgressParent = Progress(totalUnitCount: Int64(reporter.manager.totalCount ?? 0))
-        ghostProgressParent.completedUnitCount = Int64(reporter.manager.completedCount)
-        self.addChild(ghostProgressParent, withPendingUnitCount: Int64(count))
-        
-        // Make observation instance
-        let reporterObservation = _NSProgressParentProgressReporterChild(
-            intermediary: ghostProgressParent,
-            reporter: reporter
+        // Create a NSProgress - ProgressReporter bridge
+        let reporterBridge = ProgressReporterBridge(
+            parent: self,
+            portion: Int64(count),
+            reporterBridge: reporter
         )
-        reporter.manager.setInteropObservationReporter(observation: reporterObservation)
+        
+        // Store bridge
+        reporter.manager.addBridge(reporterBridge: reporterBridge)
     }
 
     // MARK: Cycle detection
@@ -80,11 +75,11 @@ extension Progress {
             return false
         }
 
-        if !(self._parent() is _NSProgressParentBridge) {
+        if !(self._parent() is NSProgressBridge) {
             return self._parent().isCycle(reporter: reporter)
         }
 
-        let unwrappedParent = (self._parent() as? _NSProgressParentBridge)?.actualParent
+        let unwrappedParent = (self._parent() as? NSProgressBridge)?.manager
         if let unwrappedParent = unwrappedParent {
             if unwrappedParent === reporter.manager {
                 return true
@@ -96,105 +91,178 @@ extension Progress {
     }
 }
 
-internal final class _NSProgressParentSubprogressChild: Sendable {
-    private let ghostParent: Progress
-    private let ghostChild: ProgressManager
-    
-    fileprivate init(ghostParent: Progress, ghostChild: ProgressManager) {
-        self.ghostParent = ghostParent
-        self.ghostChild = ghostChild
+@available(FoundationPreview 6.2, *)
+//MARK: ProgressManager Parent - Progress Child Interop
+extension ProgressManager {
+
+    /// Adds a Foundation's `Progress` instance as a child which constitutes a certain `count` of `self`'s `totalCount`.
+    /// - Parameters:
+    ///   - count: Number of units delegated from `self`'s `totalCount`.
+    ///   - progress: `Progress` which receives the delegated `count`.
+    public func subprogress(assigningCount count: Int, to progress: Foundation.Progress) {
+        precondition(progress._parent() == nil, "Cannot assign a progress to more than one parent.")
+        
+        // Create a ProgressManager - NSProgress bridge
+        let progressBridge = NSProgressBridge(
+            manager: self,
+            progress: progress,
+            portion: count
+        )
 
-        // Set up mirroring observation relationship between ghostChild and ghostParent
-        // - Ghost Parent should mirror values from Ghost Child, and Ghost Child just mirrors values of Actual Child
-        ghostChild.addObserver { [weak self] observerState in
+        // Add bridge as a parent
+        progress._setParent(progressBridge, portion: Int64(count))
+
+        // Store bridge
+        self.addBridge(nsProgressBridge: progressBridge)
+    }
+}
+
+internal final class SubprogressBridge: Sendable {
+    
+    internal let progressBridge: Progress
+    internal let manager: ProgressManager
+    
+    init(parent: Progress, portion: Int64, manager: ProgressManager) {
+        self.manager = manager
+        self.progressBridge = Progress(totalUnitCount: 1, parent: parent, pendingUnitCount: portion)
+                
+        manager.addObserver { [weak self] observerState in
             guard let self else {
                 return
             }
 
             switch observerState {
             case .fractionUpdated(let totalCount, let completedCount):
-                self.ghostParent.completedUnitCount = Int64(completedCount)
-                self.ghostParent.totalUnitCount = Int64(totalCount)
+                self.progressBridge.completedUnitCount = Int64(completedCount)
+                self.progressBridge.totalUnitCount = Int64(totalCount)
             }
         }
     }
 }
 
-internal final class _NSProgressParentProgressReporterChild: Sendable {
-    private let intermediary: Progress
-    private let reporter: ProgressReporter
+internal final class ProgressReporterBridge: Sendable {
+    
+    internal let progressBridge: Progress
+    internal let reporterBridge: ProgressReporter
 
-    fileprivate init(intermediary: Progress, reporter: ProgressReporter) {
-        self.intermediary = intermediary
-        self.reporter = reporter
+    init(parent: Progress, portion: Int64, reporterBridge: ProgressReporter) {
+        self.progressBridge = Progress(
+            totalUnitCount: Int64(reporterBridge.manager.totalCount ?? 0),
+            parent: parent,
+            pendingUnitCount: portion
+        )
+        self.progressBridge.completedUnitCount = Int64(reporterBridge.manager.completedCount)
+        self.reporterBridge = reporterBridge
+                
+        let manager = reporterBridge.manager
 
-        reporter.manager.addObserver { [weak self] observerState in
+        manager.addObserver { [weak self] observerState in
             guard let self else {
                 return
             }
 
             switch observerState {
             case .fractionUpdated(let totalCount, let completedCount):
-                self.intermediary.completedUnitCount = Int64(completedCount)
-                self.intermediary.totalUnitCount = Int64(totalCount)
+                self.progressBridge.completedUnitCount = Int64(completedCount)
+                self.progressBridge.totalUnitCount = Int64(totalCount)
             }
         }
     }
 
 }
 
-@available(FoundationPreview 6.2, *)
-//MARK: ProgressManager Parent - Progress Child Interop
-extension ProgressManager {
-
-    /// Adds a Foundation's `Progress` instance as a child which constitutes a certain `count` of `self`'s `totalCount`.
-    /// - Parameters:
-    ///   - count: Number of units delegated from `self`'s `totalCount`.
-    ///   - progress: `Progress` which receives the delegated `count`.
-    public func subprogress(assigningCount count: Int, to progress: Foundation.Progress) {
-        precondition(progress._parent() == nil, "Cannot assign a progress to more than one parent.")
-        
-        let parentBridge = _NSProgressParentBridge(managerParent: self, progressChild: progress, portion: count)
-        progress._setParent(parentBridge, portion: Int64(count))
-
-        // Save ghost parent in ProgressManager so it doesn't go out of scope after assign method ends
-        // So that when NSProgress increases completedUnitCount and queries for parent there is still a reference to ghostParent and parent doesn't show 0x0 (portion: 5)
-        self.setParentBridge(parentBridge: parentBridge)
-    }
-}
-
-// Subclass of Foundation.Progress
-internal final class _NSProgressParentBridge: Progress, @unchecked Sendable {
+internal final class NSProgressBridge: Progress, @unchecked Sendable {
 
-    internal let actualParent: ProgressManager
-    internal let actualChild: Progress
-    internal let ghostChild: ProgressManager
+    internal let manager: ProgressManager
+    internal let managerBridge: ProgressManager
+    internal let progress: Progress
 
-    init(managerParent: ProgressManager, progressChild: Progress, portion: Int) {
-        self.actualParent = managerParent
-        self.actualChild = progressChild
-        self.ghostChild = ProgressManager(totalCount: Int(progressChild.totalUnitCount))
+    init(manager: ProgressManager, progress: Progress, portion: Int) {
+        self.manager = manager
+        self.managerBridge = ProgressManager(totalCount: Int(progress.totalUnitCount))
+        self.progress = progress
         super.init(parent: nil, userInfo: nil)
 
-        // Make ghostChild mirror progressChild, ghostChild is added as a child to managerParent
-        ghostChild.withProperties { properties in
-            properties.completedCount = Int(progressChild.completedUnitCount)
+        managerBridge.withProperties { properties in
+            properties.completedCount = Int(progress.completedUnitCount)
         }
 
-        let position = managerParent.addChild(child: ghostChild, portion: portion, childFraction: ProgressFraction(completed: Int(completedUnitCount), total: Int(totalUnitCount)))
-        
-        ghostChild.addParent(parent: managerParent, positionInParent: position)
+        let position = manager.addChild(
+            child: managerBridge,
+            portion: portion,
+            childFraction: ProgressFraction(completed: Int(completedUnitCount), total: Int(totalUnitCount))
+        )
+        managerBridge.addParent(parent: manager, positionInParent: position)
     }
 
     // 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) {
-        ghostChild.withProperties { properties in
+        managerBridge.withProperties { properties in
             properties.totalCount = Int(fraction.next.total)
             properties.completedCount = Int(fraction.next.completed)
         }
 
-        ghostChild.markSelfDirty()
+        managerBridge.markSelfDirty()
+    }
+}
+
+@available(FoundationPreview 6.2, *)
+extension ProgressManager {
+    internal enum ObserverState {
+        case fractionUpdated(totalCount: Int, completedCount: Int)
+    }
+    
+    internal struct InteropObservation {
+        let subprogressBridge: SubprogressBridge?
+        var reporterBridge: ProgressReporterBridge?
+        var nsProgressBridge: Foundation.Progress?
+    }
+}
+
+extension ProgressManager.State {
+    internal func notifyObservers(with observerState: ProgressManager.ObserverState) {
+        for observer in observers {
+            observer(observerState)
+        }
+    }
+}
+
+@available(FoundationPreview 6.2, *)
+extension ProgressManager {
+    //MARK: Interop Methods
+    /// Adds `observer` to list of `_observers` in `self`.
+    internal func addObserver(observer: @escaping @Sendable (ObserverState) -> Void) {
+        state.withLock { state in
+            state.observers.append(observer)
+        }
+    }
+    
+    /// Notifies all `_observers` of `self` when `state` changes.
+    internal func notifyObservers(with observedState: ObserverState) {
+        state.withLock { state in
+            for observer in state.observers {
+                observer(observedState)
+            }
+        }
+    }
+    
+    internal func addBridge(reporterBridge: ProgressReporterBridge? = nil, nsProgressBridge: Foundation.Progress? = nil) {
+        state.withLock { state in
+            if let reporterBridge {
+                state.interopObservation.reporterBridge = reporterBridge
+            }
+            
+            if let nsProgressBridge {
+                state.interopObservation.nsProgressBridge = nsProgressBridge
+            }
+        }
+    }
+    
+    internal func setInteropChild(interopChild: ProgressManager) {
+        state.withLock { state in
+            state.interopChild = interopChild
+        }
     }
 }
 #endif