Merge pull request #12 from ECFMP/data-update-events

Data update events

Author: Andy Ford

include/ECFMP/ECFMP.h

@@ -9,6 +9,7 @@
 #include "ECFMP/eventbus/EventListener.h"
 #include "ECFMP/flightinformationregion/FlightInformationRegion.h"
 #include "ECFMP/flowmeasure/AirportFilter.h"
+#include "ECFMP/flowmeasure/CanonicalFlowMeasureInfo.h"
 #include "ECFMP/flowmeasure/EventFilter.h"
 #include "ECFMP/flowmeasure/FlowMeasure.h"
 #include "ECFMP/flowmeasure/FlowMeasureFilters.h"

include/ECFMP/Sdk.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "api/ElementCollectionTypes.h"
 
 namespace ECFMP {
     namespace EventBus {
@@ -19,6 +20,23 @@ namespace ECFMP::Plugin {
         public:
         virtual ~Sdk() = default;
 
+        /**
+         * All the flight information regions that are currently loaded.
+         */
+        [[nodiscard]] virtual auto FlightInformationRegions() const noexcept
+                -> std::shared_ptr<const Api::FlightInformationRegionCollection> = 0;
+
+        /**
+         * All the events that are currently loaded.
+         */
+        [[nodiscard]] virtual auto Events() const noexcept -> std::shared_ptr<const Api::EventCollection> = 0;
+
+        /**
+         * All the flow measures that are currently loaded.
+         */
+        [[nodiscard]] virtual auto FlowMeasures() const noexcept
+                -> std::shared_ptr<const Api::FlowMeasureCollection> = 0;
+
         /**
          * The event bus for the SDK, which can be used to subscribe to events.
          */

include/ECFMP/SdkEvents.h

@@ -1,28 +1,40 @@
 #pragma once
+#include "ECFMP/api/ElementCollectionTypes.h"
 
 namespace ECFMP::FlowMeasure {
     class FlowMeasure;
 }// namespace ECFMP::FlowMeasure
 
 namespace ECFMP::Plugin {
+
+    // Events
+    using EventsUpdatedEvent = struct EventsUpdatedEvent {
+        std::shared_ptr<ECFMP::Api::EventCollection> events;
+    };
+
+    // Flow measures
+    using FlowMeasuresUpdatedEvent = struct FlowMeasureUpdatedEvent {
+        std::shared_ptr<ECFMP::Api::FlowMeasureCollection> flowMeasures;
+    };
+
     using FlowMeasureNotifiedEvent = struct FlowMeasureNotifiedEvent {
-        const FlowMeasure::FlowMeasure& measure;
+        std::shared_ptr<const FlowMeasure::FlowMeasure> flowMeasure;
     };
 
     using FlowMeasureActivatedEvent = struct FlowMeasureActivatedEvent {
-        const FlowMeasure::FlowMeasure& measure;
+        std::shared_ptr<const FlowMeasure::FlowMeasure> flowMeasure;
     };
 
     using FlowMeasureExpiredEvent = struct FlowMeasureExpiredEvent {
-        const FlowMeasure::FlowMeasure& measure;
+        std::shared_ptr<const FlowMeasure::FlowMeasure> flowMeasure;
     };
 
     using FlowMeasureWithdrawnEvent = struct FlowMeasureWithdrawnEvent {
-        const FlowMeasure::FlowMeasure& measure;
+        std::shared_ptr<const FlowMeasure::FlowMeasure> flowMeasure;
     };
 
     using FlowMeasureReissuedEvent = struct FlowMeasureReissuedEvent {
-        const FlowMeasure::FlowMeasure& original;
-        const FlowMeasure::FlowMeasure& reissued;
+        std::shared_ptr<const FlowMeasure::FlowMeasure> original;
+        std::shared_ptr<const FlowMeasure::FlowMeasure> reissued;
     };
 }// namespace ECFMP::Plugin

include/ECFMP/SdkFactory.h

@@ -55,7 +55,7 @@ namespace ECFMP::Plugin {
          *
          * Throws an SdkConfigurationException if the configuration is bad.
          */
-        [[nodiscard]] auto Instance() -> std::unique_ptr<Sdk>;
+        [[nodiscard]] auto Instance() -> std::shared_ptr<Sdk>;
 
         private:
         SdkFactory();

include/ECFMP/eventbus/EventBus.h

@@ -1,5 +1,7 @@
 #pragma once
-#include "eventbus/InternalEventStream.h"
+#include "../../src/eventbus/EventDispatcherFactory.h"
+#include "../../src/eventbus/EventStream.h"
+#include "../../src/eventbus/SubscriptionFlags.h"
 #include <any>
 #include <mutex>
 #include <typeindex>
@@ -10,6 +12,12 @@ namespace ECFMP::EventBus {
     class EventBus
     {
         public:
+        explicit EventBus(const std::shared_ptr<EventDispatcherFactory>& dispatcherFactory)
+            : dispatcherFactory(dispatcherFactory)
+        {
+            assert(dispatcherFactory != nullptr && "Dispatcher factory cannot be null");
+        }
+
         virtual ~EventBus() = default;
         /**
          * Subscribes the given listener to the event stream.
@@ -24,7 +32,15 @@ namespace ECFMP::EventBus {
         void
         Subscribe(std::shared_ptr<EventListener<EventType>> listener, std::shared_ptr<EventFilter<EventType>> filter)
         {
-            GetStream<EventType>().Subscribe(listener, filter);
+            if (listener == nullptr) {
+                throw std::invalid_argument("Listener cannot be null");
+            }
+
+            Subscribe<EventType>(EventSubscription{
+                    dispatcherFactory->CreateDispatcher<EventType>(listener, EventDispatchMode::Euroscope),
+                    listener,
+                    filter,
+                    {EventDispatchMode::Euroscope, false}});
         };
 
         /**
@@ -41,7 +57,15 @@ namespace ECFMP::EventBus {
                 std::shared_ptr<EventListener<EventType>> listener, std::shared_ptr<EventFilter<EventType>> filter
         )
         {
-            GetStream<EventType>().SubscribeOnce(listener, filter);
+            if (listener == nullptr) {
+                throw std::invalid_argument("Listener cannot be null");
+            }
+
+            Subscribe<EventType>(EventSubscription{
+                    dispatcherFactory->CreateDispatcher<EventType>(listener, EventDispatchMode::Euroscope),
+                    listener,
+                    filter,
+                    {EventDispatchMode::Euroscope, true}});
         };
 
         /**
@@ -55,18 +79,28 @@ namespace ECFMP::EventBus {
             return GetStream<EventType>().template HasListenerOfType<ListenerType>();
         }
 
+        protected:
+        template<typename ListenerType, typename EventType>
+        void Subscribe(const EventSubscription<EventType>& subscription)
+        {
+            GetStream<EventType>().Subscribe(subscription);
+        }
+
+        // Factory for dispatchers
+        std::shared_ptr<EventDispatcherFactory> dispatcherFactory;
+
         private:
         template<typename EventType>
-        auto GetStream() -> InternalEventStream<EventType>&
+        auto GetStream() -> EventStream<EventType>&
         {
             auto lock = std::lock_guard(mutex);
 
             const auto index = std::type_index(typeid(EventType));
             if (!streams.contains(index)) {
-                streams.insert({index, std::any(std::make_shared<InternalEventStream<EventType>>())});
+                streams.insert({index, std::any(std::make_shared<EventStream<EventType>>())});
             }
 
-            return *std::any_cast<std::shared_ptr<InternalEventStream<EventType>>>(streams.at(index));
+            return *std::any_cast<std::shared_ptr<EventStream<EventType>>>(streams.at(index));
         }
 
         // Protects the streams map

include/ECFMP/eventbus/EventFilter.h

@@ -7,6 +7,6 @@ namespace ECFMP::EventBus {
     {
         public:
         virtual ~EventFilter() = default;
-        virtual bool ShouldProcess(const EventType&) = 0;
+        virtual bool ShouldProcess(const EventType& event) = 0;
     };
 }// namespace ECFMP::EventBus

include/ECFMP/eventbus/EventListener.h

@@ -6,6 +6,6 @@ namespace ECFMP::EventBus {
     {
         public:
         virtual ~EventListener() = default;
-        virtual void OnEvent(const EventType&) = 0;
+        virtual void OnEvent(const EventType& event) = 0;
     };
 }// namespace ECFMP::EventBus

include/ECFMP/eventbus/EventStream.h

@@ -0,0 +1,27 @@
+#pragma once
+
+namespace ECFMP::FlowMeasure {
+
+    /**
+         * Contains information about a canonical flow measure.
+         */
+    class CanonicalFlowMeasureInfo
+    {
+        public:
+        CanonicalFlowMeasureInfo(const std::string& identifier);
+        [[nodiscard]] auto Identifier() const noexcept -> const std::string&;
+        [[nodiscard]] auto Revision() const noexcept -> int;
+        [[nodiscard]] auto IsAfter(const CanonicalFlowMeasureInfo& other) const noexcept -> bool;
+
+        private:
+        [[nodiscard]] static auto ParseIdentifier(const std::string& identifier) -> std::string;
+        [[nodiscard]] static auto ParseRevision(const std::string& identifier) -> int;
+
+        // The identifier of the canonical flow measure
+        std::string identifier;
+
+        // The revision of the canonical flow measure
+        int revision;
+    };
+
+}// namespace ECFMP::FlowMeasure

include/ECFMP/flowmeasure/CanonicalFlowMeasureInfo.h

@@ -13,6 +13,7 @@ namespace ECFMP {
 namespace ECFMP::FlowMeasure {
     class FlowMeasureFilters;
     class Measure;
+    class CanonicalFlowMeasureInfo;
 
     /**
      * Represents the status of the flow measure
@@ -111,5 +112,8 @@ namespace ECFMP::FlowMeasure {
          * Returns a collection of filters that apply to the flow measure.
          */
         [[nodiscard]] virtual auto Filters() const noexcept -> const FlowMeasureFilters& = 0;
+
+        // Information about the canonical nature of the flow measure
+        [[nodiscard]] virtual auto CanonicalInformation() const noexcept -> const CanonicalFlowMeasureInfo& = 0;
     };
 }// namespace ECFMP::FlowMeasure