V 4.1.0 - New Listener and Thread Callback System

- Added a new `@EventMethod` Property Wrapper to enable in-line, automatically-registering Event-invoked Callback Methods on any class implementing `EventListening` (for automatic registration)
- Any Class implementing `EventListening` can now invoke `registerListeners()` at the end of its `init` method (or anywhere post-init you wish to do so, anyway) to automatically register all `@EventMethod`-decorated Event Callbacks.
- Added a version of `@EventMethod` specifically for use in `EventThread` types. You don't need to invoke `registerListeners()` for your `EventThread` types, because the base `init` will already do this for you.
- `EventThread` now supports multiple Callbacks for the same `Eventable` type. Invoking `addEventCallback` will now return a `UUID` containing the unique `token` of each Callback. This can be used with `removeEventCallback` to unregister the Callback at any time.

Author: LK-Simon

Sources/EventDrivenSwift/Central/EventCentral.swift

@@ -74,7 +74,7 @@ final public class EventCentral: EventDispatcher, EventCentralable {
         }
     }
 
-    @discardableResult @inline(__always) public static func addListener<TEvent>(_ requester: AnyObject, _ callback: @escaping TypedEventCallback<TEvent>, forEventType: Eventable.Type, executeOn: ExecuteEventOn = .requesterThread) -> UUID where TEvent : Eventable {
+    @discardableResult @inline(__always) public static func addListener<TEvent>(_ requester: AnyObject?, _ callback: @escaping TypedEventCallback<TEvent>, forEventType: Eventable.Type, executeOn: ExecuteEventOn = .requesterThread) -> UUID where TEvent : Eventable {
         return _shared.eventListener.addListener(requester, callback, forEventType: forEventType, executeOn: executeOn)
     }
 

Sources/EventDrivenSwift/Central/EventCentralable.swift

@@ -68,7 +68,7 @@ public protocol EventCentralable {
         - forEventType: The `Eventable` Type for which to Register  the Callback
      - Returns: A `UUID` value representing the `token` associated with this Event Callback
      */
-    @discardableResult static func addListener<TEvent: Eventable>(_ requester: AnyObject, _ callback: @escaping TypedEventCallback<TEvent>, forEventType: Eventable.Type, executeOn: ExecuteEventOn) -> UUID
+    @discardableResult static func addListener<TEvent: Eventable>(_ requester: AnyObject?, _ callback: @escaping TypedEventCallback<TEvent>, forEventType: Eventable.Type, executeOn: ExecuteEventOn) -> UUID
 
     /**
      Locates and removes the given Listener `token` (if it exists) from the Central Event Listener

Sources/EventDrivenSwift/Event/Eventable.swift

@@ -43,7 +43,9 @@ public protocol Eventable {
         - callback: The code to invoke for the given `Eventable` Type
      - Returns: A `UUID` value representing the `token` associated with this Event Callback
      */
-    @discardableResult static func addListener<TEvent: Eventable>(_ requester: AnyObject, _ callback: @escaping TypedEventCallback<TEvent>, executeOn: ExecuteEventOn) -> UUID
+    @discardableResult static func addListener<TEvent: Eventable>(_ requester: AnyObject?, _ callback: @escaping TypedEventCallback<TEvent>, executeOn: ExecuteEventOn) -> UUID
+    
+//    @discardableResult static func addListener(_ requester: AnyObject?, _ eventType: any Eventable.Type, _ callback: @escaping TypedEventCallback<any Eventable.Type>, executeOn: ExecuteEventOn) -> UUID
 
     /**
      Locates and removes the given Listener `token` (if it exists) from the Central Event Listener
@@ -80,11 +82,12 @@ extension Eventable {
         EventCentral.stackEvent(self, priority: priority)
     }
 
-    @discardableResult static public func addListener<TEvent: Eventable>(_ requester: AnyObject, _ callback: @escaping TypedEventCallback<TEvent>, executeOn: ExecuteEventOn = .requesterThread) -> UUID {
+    @discardableResult static public func addListener<TEvent: Eventable>(_ requester: AnyObject?, _ callback: @escaping TypedEventCallback<TEvent>, executeOn: ExecuteEventOn = .requesterThread) -> UUID {
         return EventCentral.addListener(requester, callback, forEventType: Self.self, executeOn: executeOn)
     }
-    
+       
     public static func removeListener(_ token: UUID) {
         EventCentral.removeListener(token, typeOf: Self.self)
     }
 }
+

Sources/EventDrivenSwift/Event/Wrappers/EventMethod.swift

@@ -0,0 +1,90 @@
+//
+// EventMethod.swift
+// Copyright (c) 2022, Flowduino
+// Authored by Simon J. Stuart on 21st August 2022
+//
+// Subject to terms, restrictions, and liability waiver of the MIT License
+//
+
+import Foundation
+
+public typealias EventMethodTypedEventCallback<TOwner: AnyObject, TEvent: Any> = (_ sender: TOwner, _ event: TEvent, _ priority: EventPriority) -> ()
+
+/**
+ Any Property wrapped with `EventMethod` will automatically conform to `EventMethodContainer`
+ - Author: Simon J. Stuart
+ - Version: 4.1.0
+ - Note: This is used to conformity-test decorated `var`s to automatically register Event Listeners
+ */
+public protocol EventMethodContainer {
+    associatedtype TEventType: Eventable
+    associatedtype TOwner: AnyObject
+    
+    var wrappedValue: EventMethodTypedEventCallback<TOwner, TEventType> { get set }
+    
+    var owner: AnyObject? { get set }
+    
+    mutating func unregister()
+}
+
+/**
+ Decorate Typed Event Callback Closures as `var` with `@EventMethod<TEventType>` to automatically register them.
+ - Author: Simon J. Stuart
+ - Version: 4.1.0
+ */
+@propertyWrapper
+public struct EventMethod<TOwner: AnyObject, TEventType: Eventable>: EventMethodContainer {
+    mutating public func unregister() {
+        lock.wait()
+        if token != nil {
+            TEventType.removeListener(token!)
+            token = nil
+        }
+        lock.signal()
+    }
+    
+    private var token: UUID? = nil
+    private var lock = DispatchSemaphore(value: 1)
+    
+    public var wrappedValue: EventMethodTypedEventCallback<TOwner, TEventType> {
+        didSet {
+            reRegsiterListener()
+        }
+    }
+    public var executeOn: ExecuteEventOn {
+        didSet {
+            reRegsiterListener()
+        }
+    }
+    
+    public var owner: AnyObject? {
+        didSet {
+            reRegsiterListener()
+        }
+    }
+    
+    private func callback(event: TEventType, priority: EventPriority) {
+        if let typedOwner = owner as? TOwner {
+            wrappedValue(typedOwner, event, priority)
+        }
+    }
+    
+    mutating private func reRegsiterListener() {
+        lock.wait()
+        if token != nil {
+            TEventType.removeListener(token!)
+        }
+        if owner != nil {
+            token = TEventType.addListener(
+                owner,
+                callback,
+                executeOn: executeOn)
+        }
+        lock.signal()
+    }
+    
+    public init(wrappedValue: @escaping EventMethodTypedEventCallback<TOwner, TEventType>, executeOn: ExecuteEventOn = .requesterThread) {
+        self.wrappedValue = wrappedValue
+        self.executeOn = executeOn
+    }
+}

Sources/EventDrivenSwift/EventListener/EventListenable.swift

@@ -13,7 +13,7 @@ import Foundation
  - Author: Simon J. Stuart
  - Version: 3.0.0
  */
-typealias EventCallback = (_ event: any Eventable, _ priority: EventPriority) -> ()
+public typealias EventCallback = (_ event: any Eventable, _ priority: EventPriority) -> ()
 
 /**
  Convienience `typealias` used for Typed Event Callbacks
@@ -61,7 +61,7 @@ public protocol EventListenable: AnyObject, EventReceiving {
         - executeOn: Tells the `EventListenable` whether to execute the Callback on the `requester`'s Thread, or the Listener's.
      - Returns: A `UUID` value representing the `token` associated with this Event Callback
      */
-    @discardableResult func addListener<TEvent: Eventable>(_ requester: AnyObject, _ callback: @escaping TypedEventCallback<TEvent>, forEventType: Eventable.Type, executeOn: ExecuteEventOn) -> UUID
+    @discardableResult func addListener<TEvent: Eventable>(_ requester: AnyObject?, _ callback: @escaping TypedEventCallback<TEvent>, forEventType: Eventable.Type, executeOn: ExecuteEventOn) -> UUID
 
     /**
      Locates and removes the given Listener `token` (if it exists)

Sources/EventDrivenSwift/EventListener/EventListener.swift

@@ -80,7 +80,7 @@ open class EventListener: EventHandler, EventListenable {
         }
     }
 
-    @discardableResult public func addListener<TEvent: Eventable>(_ requester: AnyObject, _ callback: @escaping TypedEventCallback<TEvent>, forEventType: Eventable.Type, executeOn: ExecuteEventOn = .requesterThread) -> UUID {
+    @discardableResult public func addListener<TEvent: Eventable>(_ requester: AnyObject?, _ callback: @escaping TypedEventCallback<TEvent>, forEventType: Eventable.Type, executeOn: ExecuteEventOn = .requesterThread) -> UUID {
         let eventTypeName = String(reflecting: forEventType)
         let method: EventCallback = { event, priority in
             self.callTypedEventCallback(callback, forEvent: event, priority: priority)

Sources/EventDrivenSwift/EventListener/EventListening.swift

@@ -0,0 +1,58 @@
+//
+// EventListening.swift
+// Copyright (c) 2022, Flowduino
+// Authored by Simon J. Stuart on 4th August 2022
+//
+// Subject to terms, restrictions, and liability waiver of the MIT License
+//
+
+import Foundation
+
+public protocol EventListening: AnyObject {
+    /**
+     Invoke this method to automatically register any Event Listener callback bearing the `@EventMethod` wrapper.
+     - Author: Simon J. Stuart
+     - Version: 4.1.0
+     - Note: Any Event Callback implemented this way will be automatically registered for you.
+     ````
+     @EventMethod<MyEventThreadType, MyEventType>
+     private var onMyEvent = {
+        (self, event: MyEventType, priority: EventPriority) in
+            /// Do something with `MyEventType` via its `event` reference here
+     }
+     ````
+     */
+    func registerListeners()
+    
+    /**
+     Invoke this method to automatically unregister any Event Listener callback bearing the `@EventMethod` wrapper.
+     - Author: Simon J. Stuart
+     - Version: 4.1.0
+     */
+    func unregisterListeners()
+}
+
+/**
+ Universal implementations to automatically Register and Unregister `@EventMethod`-decorated Event Listener Callbacks using Reflection
+ - Author: Simon J. Stuart
+ - Version: 4.1.0
+ */
+public extension EventListening {
+    func registerListeners() {
+        let mirror = Mirror(reflecting: self)
+        for child in mirror.children {
+            if var child = child.value as? (any EventMethodContainer) {
+                child.owner = self
+            }
+        }
+    }
+    
+    func unregisterListeners() {
+        let mirror = Mirror(reflecting: self)
+        for child in mirror.children {
+            if var child = child.value as? (any EventMethodContainer) {
+                child.unregister()
+            }
+        }
+    }
+}

Sources/EventDrivenSwift/EventReceiver/EventReceiver.swift

@@ -20,5 +20,5 @@ import Observable
  - Note: `EventThread` inherits from this
  */
 open class EventReceiver: EventHandler, EventReceiving {
-
+    
 }