refactor: rename ConcreteSDK

AndyTWF · AndyTWF · commit 0d47de287671 · 2023-07-30T17:45:00.000+01:00
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -30,8 +30,8 @@ set(src_pch
         pch.h pch.cpp)
 
 set(src_plugin
-        plugin/ConcreteSdk.h
-        plugin/ConcreteSdk.cpp
+        plugin/InternalSdk.h
+        plugin/InternalSdk.cpp
         plugin/SdkFactory.cpp ../include/ECFMP/SdkEvents.h plugin/InternalSdkEvents.h)
 
 set(src_time time/Clock.cpp time/Clock.h)
diff --git a/src/plugin/InternalSdk.cpp b/src/plugin/InternalSdk.cpp
@@ -1,9 +1,9 @@
-#include "ConcreteSdk.h"
+#include "InternalSdk.h"
 #include "InternalSdkEvents.h"
 #include "eventbus/InternalEventBus.h"
 
 namespace ECFMP::Plugin {
-    ConcreteSdk::ConcreteSdk(std::shared_ptr<EventBus::InternalEventBus> eventBus)
+    InternalSdk::InternalSdk(std::shared_ptr<EventBus::InternalEventBus> eventBus)
         : eventBus(std::move(eventBus)),
           flightInformationRegions(std::make_shared<Api::InternalFlightInformationRegionCollection>()),
           events(std::make_shared<Api::InternalEventCollection>()),
@@ -12,53 +12,53 @@ namespace ECFMP::Plugin {
         assert(this->eventBus && "Event bus not set in ConcreteSdk");
     }
 
-    void ConcreteSdk::Destroy()
+    void InternalSdk::Destroy()
     {
         eventBus.reset();
     }
 
-    auto ConcreteSdk::EventBus() const noexcept -> EventBus::EventBus&
+    auto InternalSdk::EventBus() const noexcept -> EventBus::EventBus&
     {
         return *eventBus;
     }
 
-    void ConcreteSdk::OnEuroscopeTimerTick()
+    void InternalSdk::OnEuroscopeTimerTick()
     {
         eventBus->OnEvent<EuroscopeTimerTickEvent>(EuroscopeTimerTickEvent{});
     }
 
-    auto ConcreteSdk::FlightInformationRegions() const noexcept
+    auto InternalSdk::FlightInformationRegions() const noexcept
             -> std::shared_ptr<const Api::FlightInformationRegionCollection>
     {
         auto lock = std::lock_guard(mutex);
         return flightInformationRegions;
     }
 
-    void ConcreteSdk::OnEvent(const FlightInformationRegionsUpdatedEvent& event)
+    void InternalSdk::OnEvent(const FlightInformationRegionsUpdatedEvent& event)
     {
         auto lock = std::lock_guard(mutex);
         flightInformationRegions = event.firs;
     }
 
-    auto ConcreteSdk::Events() const noexcept -> std::shared_ptr<const Api::EventCollection>
+    auto InternalSdk::Events() const noexcept -> std::shared_ptr<const Api::EventCollection>
     {
         auto lock = std::lock_guard(mutex);
         return events;
     }
 
-    void ConcreteSdk::OnEvent(const EventsUpdatedEvent& event)
+    void InternalSdk::OnEvent(const EventsUpdatedEvent& event)
     {
         auto lock = std::lock_guard(mutex);
         events = event.events;
     }
 
-    auto ConcreteSdk::FlowMeasures() const noexcept -> std::shared_ptr<const Api::FlowMeasureCollection>
+    auto InternalSdk::FlowMeasures() const noexcept -> std::shared_ptr<const Api::FlowMeasureCollection>
     {
         auto lock = std::lock_guard(mutex);
         return flowMeasures;
     }
 
-    void ConcreteSdk::OnEvent(const FlowMeasuresUpdatedEvent& eventType)
+    void InternalSdk::OnEvent(const FlowMeasuresUpdatedEvent& eventType)
     {
         auto lock = std::lock_guard(mutex);
         flowMeasures = eventType.flowMeasures;
diff --git a/src/plugin/InternalSdk.h b/src/plugin/InternalSdk.h
@@ -17,14 +17,14 @@ namespace ECFMP {
 
 namespace ECFMP::Plugin {
 
-    class ConcreteSdk : public Sdk,
+    class InternalSdk : public Sdk,
                         public EventBus::EventListener<Plugin::FlightInformationRegionsUpdatedEvent>,
                         public EventBus::EventListener<Plugin::EventsUpdatedEvent>,
                         public EventBus::EventListener<Plugin::FlowMeasuresUpdatedEvent>
     {
         public:
-        ConcreteSdk(std::shared_ptr<EventBus::InternalEventBus> eventBus);
-        ~ConcreteSdk() override = default;
+        InternalSdk(std::shared_ptr<EventBus::InternalEventBus> eventBus);
+        ~InternalSdk() override = default;
 
         [[nodiscard]] auto FlightInformationRegions() const noexcept
                 -> std::shared_ptr<const Api::FlightInformationRegionCollection> override;
diff --git a/src/plugin/SdkFactory.cpp b/src/plugin/SdkFactory.cpp
@@ -1,9 +1,9 @@
 #include "ECFMP/SdkFactory.h"
-#include "ConcreteSdk.h"
 #include "ECFMP/SdkEvents.h"
 #include "ECFMP/flightinformationregion/FlightInformationRegion.h"
 #include "ECFMP/http/HttpClient.h"
 #include "ECFMP/log/Logger.h"
+#include "InternalSdk.h"
 #include "InternalSdkEvents.h"
 #include "api/ApiDataDownloadedEvent.h"
 #include "api/ApiDataDownloader.h"
@@ -136,7 +136,7 @@ namespace ECFMP::Plugin {
         impl->RegisterEventListeners();
 
         // Set up the SDK
-        auto sdk = std::make_shared<ConcreteSdk>(impl->GetEventBus());
+        auto sdk = std::make_shared<InternalSdk>(impl->GetEventBus());
         impl->GetEventBus()->SubscribeAsync<Plugin::FlightInformationRegionsUpdatedEvent>(sdk);
         impl->GetEventBus()->SubscribeAsync<Plugin::EventsUpdatedEvent>(sdk);
         impl->GetEventBus()->SubscribeAsync<Plugin::FlowMeasuresUpdatedEvent>(sdk);
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -60,7 +60,7 @@ set(test__pch
 
 set(test__plugin
         plugin/SdkFactoryTest.cpp
-        plugin/ConcreteSdkTest.cpp)
+        plugin/InternalSdkTest.cpp)
 
 set(test__other
         main.cpp
diff --git a/test/plugin/InternalSdkTest.cpp b/test/plugin/InternalSdkTest.cpp
@@ -1,7 +1,7 @@
-#include "plugin/ConcreteSdk.h"
 #include "ECFMP/eventbus/EventListener.h"
 #include "eventbus/InternalEventBusFactory.h"
 #include "mock/MockHttpClient.h"
+#include "plugin/InternalSdk.h"
 
 namespace ECFMPTest::Plugin {
 
@@ -24,7 +24,7 @@ namespace ECFMPTest::Plugin {
         {}
 
         std::shared_ptr<ECFMP::EventBus::InternalEventBus> eventBus;
-        ECFMP::Plugin::ConcreteSdk instance;
+        ECFMP::Plugin::InternalSdk instance;
     };
 
     TEST_F(ConcreteSdkTest, OnEuroscopeTimerTickTriggersEvent)
diff --git a/test/plugin/SdkFactoryTest.cpp b/test/plugin/SdkFactoryTest.cpp
@@ -11,7 +11,7 @@
 #include "flowmeasure/FlowMeasureStatusUpdates.h"
 #include "mock/MockHttpClient.h"
 #include "mock/MockLogger.h"
-#include "plugin/ConcreteSdk.h"
+#include "plugin/InternalSdk.h"
 #include "plugin/InternalSdkEvents.h"
 
 namespace ECFMPTest::Plugin {
@@ -102,7 +102,7 @@ namespace ECFMPTest::Plugin {
         auto hasListener =
                 InternalBus(instance)
                         .HasListenerForSubscription<
-                                ECFMP::Plugin::ConcreteSdk, ECFMP::Plugin::FlightInformationRegionsUpdatedEvent>(
+                                ECFMP::Plugin::InternalSdk, ECFMP::Plugin::FlightInformationRegionsUpdatedEvent>(
                                 {ECFMP::EventBus::EventDispatchMode::Async, false}
                         );
         EXPECT_TRUE(hasListener);
@@ -114,7 +114,7 @@ namespace ECFMPTest::Plugin {
         const auto instance = ECFMP::Plugin::SdkFactory::Build().WithHttpClient(std::move(http)).Instance();
         auto hasListener =
                 InternalBus(instance)
-                        .HasListenerForSubscription<ECFMP::Plugin::ConcreteSdk, ECFMP::Plugin::EventsUpdatedEvent>(
+                        .HasListenerForSubscription<ECFMP::Plugin::InternalSdk, ECFMP::Plugin::EventsUpdatedEvent>(
                                 {ECFMP::EventBus::EventDispatchMode::Async, false}
                         );
         EXPECT_TRUE(hasListener);
@@ -126,7 +126,7 @@ namespace ECFMPTest::Plugin {
         const auto instance = ECFMP::Plugin::SdkFactory::Build().WithHttpClient(std::move(http)).Instance();
         auto hasListener = InternalBus(instance)
                                    .HasListenerForSubscription<
-                                           ECFMP::Plugin::ConcreteSdk, ECFMP::Plugin::FlowMeasuresUpdatedEvent>(
+                                           ECFMP::Plugin::InternalSdk, ECFMP::Plugin::FlowMeasuresUpdatedEvent>(
                                            {ECFMP::EventBus::EventDispatchMode::Async, false}
                                    );
         EXPECT_TRUE(hasListener);

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,9 @@`
`1`		`-#include "ConcreteSdk.h"`
	`1`	`+#include "InternalSdk.h"`
`2`	`2`	`#include "InternalSdkEvents.h"`
`3`	`3`	`#include "eventbus/InternalEventBus.h"`
`4`	`4`
`5`	`5`	`namespace ECFMP::Plugin {`
`6`		`- ConcreteSdk::ConcreteSdk(std::shared_ptr<EventBus::InternalEventBus> eventBus)`
	`6`	`+ InternalSdk::InternalSdk(std::shared_ptr<EventBus::InternalEventBus> eventBus)`
`7`	`7`	`: eventBus(std::move(eventBus)),`
`8`	`8`	`flightInformationRegions(std::make_shared<Api::InternalFlightInformationRegionCollection>()),`
`9`	`9`	`events(std::make_shared<Api::InternalEventCollection>()),`
`@@ -12,53 +12,53 @@ namespace ECFMP::Plugin {`
`12`	`12`	`assert(this->eventBus && "Event bus not set in ConcreteSdk");`
`13`	`13`	`}`
`14`	`14`
`15`		`- void ConcreteSdk::Destroy()`
	`15`	`+ void InternalSdk::Destroy()`
`16`	`16`	`{`
`17`	`17`	`eventBus.reset();`
`18`	`18`	`}`
`19`	`19`
`20`		`- auto ConcreteSdk::EventBus() const noexcept -> EventBus::EventBus&`
	`20`	`+ auto InternalSdk::EventBus() const noexcept -> EventBus::EventBus&`
`21`	`21`	`{`
`22`	`22`	`return *eventBus;`
`23`	`23`	`}`
`24`	`24`
`25`		`- void ConcreteSdk::OnEuroscopeTimerTick()`
	`25`	`+ void InternalSdk::OnEuroscopeTimerTick()`
`26`	`26`	`{`
`27`	`27`	`eventBus->OnEvent<EuroscopeTimerTickEvent>(EuroscopeTimerTickEvent{});`
`28`	`28`	`}`
`29`	`29`
`30`		`- auto ConcreteSdk::FlightInformationRegions() const noexcept`
	`30`	`+ auto InternalSdk::FlightInformationRegions() const noexcept`
`31`	`31`	`-> std::shared_ptr<const Api::FlightInformationRegionCollection>`
`32`	`32`	`{`
`33`	`33`	`auto lock = std::lock_guard(mutex);`
`34`	`34`	`return flightInformationRegions;`
`35`	`35`	`}`
`36`	`36`
`37`		`- void ConcreteSdk::OnEvent(const FlightInformationRegionsUpdatedEvent& event)`
	`37`	`+ void InternalSdk::OnEvent(const FlightInformationRegionsUpdatedEvent& event)`
`38`	`38`	`{`
`39`	`39`	`auto lock = std::lock_guard(mutex);`
`40`	`40`	`flightInformationRegions = event.firs;`
`41`	`41`	`}`
`42`	`42`
`43`		`- auto ConcreteSdk::Events() const noexcept -> std::shared_ptr<const Api::EventCollection>`
	`43`	`+ auto InternalSdk::Events() const noexcept -> std::shared_ptr<const Api::EventCollection>`
`44`	`44`	`{`
`45`	`45`	`auto lock = std::lock_guard(mutex);`
`46`	`46`	`return events;`
`47`	`47`	`}`
`48`	`48`
`49`		`- void ConcreteSdk::OnEvent(const EventsUpdatedEvent& event)`
	`49`	`+ void InternalSdk::OnEvent(const EventsUpdatedEvent& event)`
`50`	`50`	`{`
`51`	`51`	`auto lock = std::lock_guard(mutex);`
`52`	`52`	`events = event.events;`
`53`	`53`	`}`
`54`	`54`
`55`		`- auto ConcreteSdk::FlowMeasures() const noexcept -> std::shared_ptr<const Api::FlowMeasureCollection>`
	`55`	`+ auto InternalSdk::FlowMeasures() const noexcept -> std::shared_ptr<const Api::FlowMeasureCollection>`
`56`	`56`	`{`
`57`	`57`	`auto lock = std::lock_guard(mutex);`
`58`	`58`	`return flowMeasures;`
`59`	`59`	`}`
`60`	`60`
`61`		`- void ConcreteSdk::OnEvent(const FlowMeasuresUpdatedEvent& eventType)`
	`61`	`+ void InternalSdk::OnEvent(const FlowMeasuresUpdatedEvent& eventType)`
`62`	`62`	`{`
`63`	`63`	`auto lock = std::lock_guard(mutex);`
`64`	`64`	`flowMeasures = eventType.flowMeasures;`