Close to v1.0.0 release-ready

All of the fundamentals are implemented, tested, and working.
- Some Thread-Safety improvements will be performed on `queue` and `stack` and `listener` collections similar to those made in the Observable library

Author: LK-Simon

.gitignore

@@ -88,3 +88,6 @@ fastlane/test_output
 # https://github.com/johnno1962/injectionforxcode
 
 iOSInjectionProject/
+
+# MacOS FileSystem
+*.DS_Store

.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,43 @@
+// swift-tools-version: 5.7
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "EventDrivenSwift",
+    platforms: [
+        .macOS(.v10_15),
+        .iOS(.v13),
+        .tvOS(.v13),
+        .watchOS(.v6)
+    ],
+    products: [
+        // Products define the executables and libraries a package produces, and make them visible to other packages.
+        .library(
+            name: "EventDrivenSwift",
+            targets: ["EventDrivenSwift"]),
+    ],
+    dependencies: [
+        // Dependencies declare other packages that this package depends on.
+        .package(url: "https://github.com/Flowduino/ThreadSafeSwift.git", .upToNextMajor(from: "1.1.0")),
+        .package(url: "https://github.com/Flowduino/Observable.git", .upToNextMajor(from: "1.1.0")),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+        // Targets can depend on other targets in this package, and on products in packages this package depends on.
+        .target(
+            name: "EventDrivenSwift",
+            dependencies: [
+                .product(name: "ThreadSafeSwift", package: "ThreadSafeSwift"),
+                .product(name: "Observable", package: "Observable"),
+            ]
+        ),
+        .testTarget(
+            name: "EventDrivenSwiftTests",
+            dependencies: [
+                "EventDrivenSwift",
+                .product(name: "ThreadSafeSwift", package: "ThreadSafeSwift"),
+                .product(name: "Observable", package: "Observable"),
+            ]),
+    ]
+)

Package.resolved

@@ -0,0 +1,31 @@
+//
+// EventCentral.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
+
+/**
+Singleton for the Central Event Handler.
+ - Author: Simon J. Stuart
+ - Version: 1.0.0
+ to access the Central Event Handler.
+ - Note: This is a Singleton!
+ - Note: This is used when invoking the `queue` and `stack` methods of `Eventable`.
+ */
+final public class EventCentral: EventDispatcher {
+    private static var _shared: EventDispatcher = EventCentral()
+    
+    public static var shared: EventDispatchable {
+        get {
+            return _shared
+        }
+    }
+    
+    override private init() {}
+    
+    
+}

Package.swift

@@ -0,0 +1,21 @@
+//
+// EventDispatchMethod.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
+
+/**
+ Specifies the Dispatch Method of a given Event
+ - Author: Simon J. Stuart
+ - Version: 1.0.0
+ */
+public enum EventDispatchMethod: CaseIterable {
+    /// The Event was dispatched through the Queue
+    case queue
+    /// The Event was dispatched through the Stack
+    case stack
+}

README.md

@@ -0,0 +1,30 @@
+//
+// EventPriority.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
+
+/**
+ Specifies the Priority of a given Event
+ - Author: Simon J. Stuart
+ - Version: 1.0.0
+ */
+public enum EventPriority: CaseIterable {
+    case lowest
+    case low
+    case normal
+    case high
+    case highest
+    
+    /**
+     Returns all of the `EventPriority` cases in order of `highest` to `lowest` (reverse order).
+     - Author: Simon J. Stuart
+     - Version: 1.0.0
+     - Note: This is necessary because we always process Events in priority-order from `highest` to `lowest`
+     */
+    public static let inOrder = Self.allCases.reversed()
+}

Sources/EventDrivenSwift/Central/EventCentral.swift

@@ -0,0 +1,62 @@
+//
+// Eventable.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
+
+/**
+ Protocol describing anything that can be dispatched as an Event
+ - Author: Simon J. Stuart
+ - Version: 1.0.0
+ - Note: You should **never** pass any `class` instance references along in an `Eventable` type.
+ - Note: `Eventable` types **must** always be **immutable**
+ */
+public protocol Eventable {
+    /**
+     Dispatch the Event to the Central Queue with the given `priority`
+     - Author: Simon J. Stuart
+     - Version: 1.0.0
+     - Parameters:
+        - priority: The Priority with which to process this Event
+     */
+    func queue(priority: EventPriority)
+    
+    /**
+     Dispatch the Event to the Central Stack with the given `priority`
+     - Author: Simon J. Stuart
+     - Version: 1.0.0
+     - Parameters:
+        - priority: The Priority with which to process this Event
+     */
+    func stack(priority: EventPriority)
+}
+
+/**
+ Extension to provide Operator Overrides for `Eventable` types
+ - Author: Simon J. Stuart
+ - Version: 1.0.0
+ */
+extension Eventable {
+    static func == (lhs: Self, rhs: Self) -> Bool {
+        return String(reflecting: lhs) == String(reflecting: rhs)
+    }
+}
+
+/**
+ Extension to provide transparent `queue` and `stack` dispatch via `EventCentral`
+ - Author: Simon J. Stuart
+ - Version: 1.0.0
+ */
+extension Eventable {
+    public func queue(priority: EventPriority = .normal) {
+        EventCentral.shared.queueEvent(self, priority: priority)
+    }
+    
+    public func stack(priority: EventPriority = .normal) {
+        EventCentral.shared.stackEvent(self, priority: priority)
+    }
+}

Sources/EventDrivenSwift/Event/EventDispatchMethod.swift

@@ -0,0 +1,37 @@
+//
+// EventDispatchable.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
+
+/**
+ Protocol describing anything that Dispatches Events
+ - Author: Simon J. Stuart
+ - Version: 1.0.0
+ */
+public protocol EventDispatchable: EventHandlable {
+    /**
+     Registers the given `listener` for the given `Eventable` Type
+     - Author: Simon J. Stuart
+     - Version: 1.0.0
+     */
+    func addListener(_ listener: any EventReceivable, forEventType: Eventable.Type)
+    
+    /**
+     Unregisters the given `listener` from the given `Eventable` Type
+     - Author: Simon J. Stuart
+     - Version: 1.0.0
+     */
+    func removeListener(_ listener: any EventReceivable, forEventType: Eventable.Type)
+    
+    /**
+     Unregisters the given `listener` from all `Eventable` Types
+     - Author: Simon J. Stuart
+     - Version: 1.0.0
+     */
+    func removeListener(_ listener: any EventReceivable)
+}