Save commands until they can execute or expire

Author: timshadel

Sources/Reactor.swift

@@ -15,9 +15,46 @@ public protocol Event {}
 
 // MARK: - Commands
 
-public protocol Command {
+public protocol AnyCommand {
+    func _execute(state: Any, core: Any)
+    func _canExecute(state: Any) -> Bool
+    var expiresAfter: TimeInterval { get }
+}
+
+extension AnyCommand {
+    var expiresAfter: TimeInterval { return 10.0 }
+}
+
+public protocol Command: AnyCommand {
     associatedtype StateType: State
     func execute(state: StateType, core: Core<StateType>)
+    func canExecute(state: StateType) -> Bool
+}
+
+extension Command {
+
+    public func canExecute(state: StateType) -> Bool {
+        return true
+    }
+
+    public func _canExecute(state: Any) -> Bool {
+        if let state = state as? StateType {
+            return canExecute(state: state)
+        } else {
+            return false
+        }
+    }
+
+    public func _execute(state: Any, core: Any) {
+        if let state = state as? StateType, let core = core as? Core<StateType> {
+            execute(state: state, core: core)
+        }
+    }
+}
+
+public struct Commands<StateType: State> {
+    private(set) var expiresAt: Date
+    private(set) var command: AnyCommand
 }
 
 
@@ -88,20 +125,33 @@ public class Core<StateType: State> {
 
     private let jobQueue:DispatchQueue = DispatchQueue(label: "reactor.core.queue", qos: .userInitiated, attributes: [])
 
-    private let subscriptionsSyncQueue = DispatchQueue(label: "reactor.core.subscription.sync")
+    private let internalSyncQueue = DispatchQueue(label: "reactor.core.internal.sync")
     private var _subscriptions = [Subscription<StateType>]()
     private var subscriptions: [Subscription<StateType>] {
         get {
-            return subscriptionsSyncQueue.sync {
+            return internalSyncQueue.sync {
                 return self._subscriptions
             }
         }
         set {
-            subscriptionsSyncQueue.sync {
+            internalSyncQueue.sync {
                 self._subscriptions = newValue
             }
         }
     }
+    private var _commands = [Commands<StateType>]()
+    private var commands: [Commands<StateType>] {
+        get {
+            return internalSyncQueue.sync {
+                return self._commands
+            }
+        }
+        set {
+            internalSyncQueue.sync {
+                self._commands = newValue
+            }
+        }
+    }
 
     private let middlewares: [Middlewares<StateType>]
     public private (set) var state: StateType {
@@ -140,13 +190,25 @@ public class Core<StateType: State> {
         jobQueue.async {
             self.state.react(to: event)
             let state = self.state
+            let executable = self.commands.enumerated().filter { $1.command._canExecute(state: state) }
+            executable.forEach {
+                self.commands.remove(at: $0)
+                $1.command._execute(state: state, core: self)
+            }
+            let now = Date()
+            let expired = self.commands.enumerated().filter { $1.expiresAt < now }
+            expired.forEach { self.commands.remove(at: $0.offset) }
             self.middlewares.forEach { $0.middleware._process(event: event, state: state) }
         }
     }
 
     public func fire<C: Command>(command: C) where C.StateType == StateType {
-        jobQueue.async {
-            command.execute(state: self.state, core: self)
+        if command.canExecute(state: state) {
+            jobQueue.async {
+                command.execute(state: self.state, core: self)
+            }
+        } else {
+            commands.append(Commands(expiresAt: Date().addingTimeInterval(command.expiresAfter), command: command))
         }
     }