README updated and EventReceiving supports .latestOnly

- Updated README.md to reflect `.latestOnly` support in Listeners
- Updated `EventReceiving` and all implementors to support `.latestOnly` as well

Author: LK-Simon

README.md

@@ -427,6 +427,30 @@ This will remove your *Listener Callback*, meaning it will no longer be invoked
 
 `EventListener`s are an extremely versatile and very powerful addition to `EventDrivenSwift`.
 
+## `EventListener` with *Latest-Only* Interest
+Version 4.3.0 of this library introduces the concept of *Latest-Only Listeners*. A *Latest-Only Listener* is a *Listener* that will only be invoked for the very latest *Event* of its requested *Event Type*. If there are a number of older *Events* of this type pending in a Queue/Stack, they will simply be skipped over... and only the very *Latest* will invoke your *Listener*.
+
+We have made it incredibly simple for you to configure your *Listener* to be a *Latest-Only Listener*. Taking the previous code example, we can simply modify it as follows:
+```swift
+class TemperatureRatingViewModel: ObservableObject {
+    @Published var temperatureInCelsius: Float
+    @Published var temperatureRating: TemperatureRating
+    
+    var listenerHandle: EventListenerHandling?
+    
+    internal func onTemperatureRatingEvent(_ event: TemperatureRatingEvent, _ priority: EventPriority) {
+        temperatureInCelsius = event.temperatureInCelsius
+        temperatureRating = event.temperatureRating
+    }
+    
+    init() {
+        // Let's register our Event Listener Callback!
+        listenerHandle = TemperatureRatingEvent.addListener(self, onTemperatureRatingEvent, interestedIn: .latestOnly)
+    }
+}
+```
+By including the `interestedIn` optional parameter when invoking `addListener` against any `Eventable` type, and passing for this parameter a value of `.latestOnly`, we define that this *Listener* is only interested in the *Latest* `TemperatureRatingEvent` to be *Dispatched*. Should a number of `TemperatureRatingEvent`s build up in the Queue/Stack, the above-defined *Listener* will simply discard any older Events, and only invoke for the newest.
+
 ## `EventPool`
 Version 4.0.0 introduces the extremely powerful `EventPool` solution, making it possible to create managed groups of `EventThread`s, where inbound *Events* will be directed to the best `EventThread` in the `EventPool` at any given moment.
 

Sources/EventDrivenSwift/EventDispatcher/EventDispatcher.swift

@@ -102,6 +102,7 @@ open class EventDispatcher: EventHandler, EventDispatching {
             if receiver.receiver == nil { /// If the Recevier is `nil`...
                 continue
             }
+            if receiver.receiver!.interestedIn == .latestOnly && event.dispatchTime < latestEventDispatchTime[event.event.getEventTypeName()]! { continue } // If this Receiver is only interested in the Latest Event dispatched for this Event Type, and this Event is NOT the Latest... skip it!
 
             // so, we have a receiver... let's deal with it!
             switch dispatchMethod {

Sources/EventDrivenSwift/EventListener/EventListener.swift

@@ -17,6 +17,8 @@ import Observable
  - Note: Inherit from this to implement a discrete unit of code designed specifically to operate upon specific `Eventable` types containing information useful to its operation(s)
  */
 open class EventListener: EventHandler, EventListenable {
+    public var interestedIn: EventListenerInterest = .all
+    
     /**
      Container for Event Listeners
      - Author: Simon J. Stuart

Sources/EventDrivenSwift/EventPool/EventPool.swift

@@ -18,6 +18,8 @@ import ThreadSafeSwift
  - Note: Event Pools own and manage all instances of the given `TEventThread` type
  */
 open class EventPool<TEventThread: EventThreadable>: EventHandler, EventPooling {
+    public var interestedIn: EventListenerInterest = .all
+    
     @ThreadSafeSemaphore public var balancer: EventPoolBalancing
     @ThreadSafeSemaphore public var scaler: EventPoolScaling
     @ThreadSafeSemaphore public var capacity: UInt8

Sources/EventDrivenSwift/EventReceiver/EventReceiver.swift

@@ -20,5 +20,5 @@ import Observable
  - Note: `EventThread` inherits from this
  */
 open class EventReceiver: EventHandler, EventReceiving {
-
+    public var interestedIn: EventListenerInterest = .all
 }

Sources/EventDrivenSwift/EventReceiver/EventReceiving.swift

@@ -14,5 +14,10 @@ import Foundation
  - Version: 1.0.0
  */
 public protocol EventReceiving: AnyObject, EventHandling {
-
+    /**
+     Declares whether this Receiver is interested in `.all` Events, or `.latestOnly`
+     - Author: Simon J. Stuart
+     - Version: 4.3.0
+     */
+    var interestedIn: EventListenerInterest { get set }
 }