Eliminated possibility of Deadlocks everywhere

Queues, Stacks, and Listeners are now immune from Deadlocking. A local copy of each of the aforementioned are taken in the operative methods that could potentially cause a deadlocked reference to these collections.

I've also streamlined the housekeeping for `nil` listeners. It's now performed casually each time an Event is being processed against each Listener.

Author: LK-Simon

Sources/EventDrivenSwift/Central/EventCentral.swift

@@ -28,13 +28,13 @@ final public class EventCentral: EventDispatcher, EventCentralable {
      - Author: Simon J. Stuart
      - Version: 1.0.0
      */
-    public static var shared: EventDispatchable {
+    @inline(__always) public static var shared: EventDispatchable {
         get {
             return _shared
         }
     }
 
-    public static subscript() -> EventDispatchable {
+    @inline(__always) public static subscript() -> EventDispatchable {
         get {
             return _shared
         }

Sources/EventDrivenSwift/EventDispatcher/EventDispatcher.swift

@@ -26,7 +26,7 @@ open class EventDispatcher: EventHandler, EventDispatchable {
      - Author: Simon J. Stuart
      - Version: 1.0.0
      */
-    @ThreadSafeSemaphore private var listeners = [String:[ListenerContainer]]() //TODO: Make this a Revolving Door collection!
+    @ThreadSafeSemaphore private var listeners = [String:[ListenerContainer]]()
 
     public func addListener(_ listener: any EventReceivable, forEventType: Eventable.Type) {
         let eventTypeName = String(reflecting: forEventType)
@@ -83,32 +83,31 @@ open class EventDispatcher: EventHandler, EventDispatchable {
     override internal func processEvent(_ event: any Eventable, dispatchMethod: EventDispatchMethod, priority: EventPriority) {
         let eventTypeName = String(reflecting: type(of: event))
 
+        var snapListeners = [String:[ListenerContainer]]()
+        
         _listeners.withLock { listeners in
-            let bucket = listeners[eventTypeName]
-            if bucket == nil { return } /// No Listeners, so nothing more to do!
-            
-            var newBucket: [ListenerContainer]? = nil
+            // We should take this opportunity to remove any nil listeners
+            listeners[eventTypeName]?.removeAll(where: { listenerContainer in
+                listenerContainer.listener == nil
+            })
+            snapListeners = listeners
+        }
+        
+        let bucket = snapListeners[eventTypeName]
+        if bucket == nil { return } /// No Listeners, so nothing more to do!
+        
+        for listener in bucket! {
+            if listener.listener == nil { /// If the Listener is `nil`...
+                continue
+            }
 
-            for listener in bucket! {
-                if listener.listener == nil { /// If the Listener is `nil`...
-                    if newBucket != nil { continue } /// ...If we've already removed all `nil` values, move on
-                    ///... otherwise, remove the Listener from this bucket
-                    newBucket = bucket
-                    newBucket?.removeAll(where: { listenerContainer in
-                        listenerContainer.listener == nil
-                    })
-                    continue
-                }
-                
-                // so, we have a listener... let's deal with it!
-                switch dispatchMethod {
-                case .stack:
-                    listener.listener!.stackEvent(event, priority: priority)
-                case .queue:
-                    listener.listener!.queueEvent(event, priority: priority)
-                }
+            // so, we have a listener... let's deal with it!
+            switch dispatchMethod {
+            case .stack:
+                listener.listener!.stackEvent(event, priority: priority)
+            case .queue:
+                listener.listener!.queueEvent(event, priority: priority)
             }
-            if newBucket != nil { listeners[eventTypeName] = newBucket }
         }
     }
 }

Sources/EventDrivenSwift/EventHandler/EventHandler.swift

@@ -107,7 +107,7 @@ open class EventHandler: ObservableThread, EventHandlable {
      - Parameters:
         - events: The `Array` of `Eventable` objects
      */
-    private func processEvents(_ events: [any Eventable], dispatchMethod: EventDispatchMethod, priority: EventPriority) {
+    @inline(__always) private func processEvents(_ events: [any Eventable], dispatchMethod: EventDispatchMethod, priority: EventPriority) {
         for event in events {
             processEvent(event, dispatchMethod: dispatchMethod, priority: priority)
         }
@@ -158,7 +158,7 @@ open class EventHandler: ObservableThread, EventHandlable {
      - Author: Simon J. Stuart
      - Version: 1.0.0
      */
-    internal func processAllEvents() {
+    @inline(__always) internal func processAllEvents() {
         processEventStacks() // we process Stacks first
         processEventQueues() // we process Queues next
     }
@@ -170,8 +170,8 @@ open class EventHandler: ObservableThread, EventHandlable {
      */
     public override func main() {
         while isExecuting {
-            eventsPending.wait()
-            processAllEvents()
+            eventsPending.wait() // This will make the Thread effectively "sleep" until there are Events pending
+            processAllEvents() // Once there's at least one Event waiting, we will Process it/them.
         }
     }
 

Sources/EventDrivenSwift/EventReceiver/EventReceiver.swift

@@ -37,7 +37,7 @@ open class EventReceiver: EventHandler, EventReceivable {
      - Version: 1.0.0
      - Note: We use the Qualified Type Name as the Key because Types are not Hashable in Swift
      */
-    @ThreadSafeSemaphore private var eventCallbacks = [String:EventCallback]() //TODO: Make this a Revolving Door collection!
+    @ThreadSafeSemaphore private var eventCallbacks = [String:EventCallback]()
 
     /**
      Invoke the appropriate Callback for the given Event