Add pause and resume API's to Loop

On some scenarios, it's useful to "pause" the `Loop` so that we stop
processing events for some reason (e.g. to stop a `Loop` backed
Service). Following the same reasoning, it becomes necessary to have a
"resume" mechanism so that the Loop starts processing events again.

Given `Loop` now starts automatically and `stop` is designed as a tear
down mechanism to be used on dealloc and dispose all observations, some
new API's are required so that we can unplug/replug feedbacks to
achieve the above mentioned pause/resume behavior.

## Changes

- Create new `plugFeedbacks` and `unplugFeedbacks` API's in
`Floodgate`, which establish and dispose feedbacks observations,
respectively. Floodgate now retains the feedbacks passed in on
`bootstrap` to use them on `plugFeedbacks`.

- Add `pause` and `resume` API's to `LoopBoxBase`.

- Implement `pause` and `resume` API's in `RootLoopBox`, which unplug
and plug the feedbacks on the `Floodgate`, respectively.

- Implement `pause` and `resume` API's in `ScopedLoopBox`, which
forward the calls to their root, respectively.

Author: p4checo

Loop/Floodgate.swift

@@ -34,7 +34,8 @@ final class Floodgate<State, Event>: FeedbackEventConsumer<Event> {
 
     private let queue = Atomic(QueueState())
     private let reducer: (inout State, Event) -> Void
-    private let feedbackDisposables = CompositeDisposable()
+    private var feedbacks: [Loop<State, Event>.Feedback] = []
+    private var feedbackDisposables = CompositeDisposable()
 
     init(state: State, reducer: @escaping (inout State, Event) -> Void) {
         self.state = state
@@ -46,6 +47,12 @@ final class Floodgate<State, Event>: FeedbackEventConsumer<Event> {
     }
 
     func bootstrap(with feedbacks: [Loop<State, Event>.Feedback]) {
+        self.feedbacks = feedbacks
+
+        plugFeedbacks()
+    }
+
+    func plugFeedbacks() {
         for feedback in feedbacks {
             // Pass `producer` which has replay-1 semantic.
             feedbackDisposables += feedback.events(
@@ -60,6 +67,11 @@ final class Floodgate<State, Event>: FeedbackEventConsumer<Event> {
         }
     }
 
+    func unplugFeedbacks() {
+        feedbackDisposables.dispose()
+        feedbackDisposables = CompositeDisposable()
+    }
+
     override func process(_ event: Event, for token: Token) {
         enqueue(event, for: token)
 

Loop/LoopBox.swift

@@ -44,6 +44,14 @@ internal class ScopedLoopBox<RootState, RootEvent, ScopedState, ScopedEvent>: Lo
             event: { [eventTransform] in eventTransform(event($0)) }
         )
     }
+
+    override func pause() {
+        root.pause()
+    }
+
+    override func resume() {
+        root.resume()
+    }
 }
 
 internal class RootLoopBox<State, Event>: LoopBoxBase<State, Event> {
@@ -83,6 +91,14 @@ internal class RootLoopBox<State, Event>: LoopBoxBase<State, Event> {
         ScopedLoopBox(root: self, value: scope, event: event)
     }
 
+    override func pause() {
+        floodgate.unplugFeedbacks()
+    }
+
+    override func resume() {
+        floodgate.plugFeedbacks()
+    }
+
     func start(with feedbacks: [Loop<State, Event>.Feedback]) {
         floodgate.bootstrap(with: feedbacks + [input.feedback])
     }
@@ -115,6 +131,10 @@ internal class LoopBoxBase<State, Event> {
     ) -> LoopBoxBase<S, E> {
         subclassMustImplement()
     }
+
+    func pause() { subclassMustImplement() }
+
+    func resume() { subclassMustImplement() }
 }
 
 @inline(never)

Loop/Public/Loop.swift

@@ -69,6 +69,14 @@ public final class Loop<State, Event> {
             box: box.scoped(to: { $0 }, event: { _ in fatalError() })
         )
     }
+
+    public func pause() {
+        box.pause()
+    }
+
+    public func resume() {
+        box.resume()
+    }
 }
 
 extension Loop {