Add modularity API

Author: adazem009

src/global/CMakeLists.txt

@@ -1,6 +1,12 @@
 set(MODULE global)
 set(MODULE_URI Global)
 set(MODULE_SRC
+    modularity/ioc.h
+    modularity/modulesioc.h
+    modularity/imoduleexportinterface.h
+    modularity/imodulesetup.h
 )
 
 include(${PROJECT_SOURCE_DIR}/build/module.cmake)
+
+add_subdirectory(test)

src/global/modularity/imoduleexportinterface.h

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#define MODULE_EXPORT_INTERFACE                                                                                                                                                                        \
+public                                                                                                                                                                                                 \
+    scratchcpp::modularity::IModuleExportInterface
+
+namespace scratchcpp::modularity
+{
+
+class IModuleExportInterface
+{
+    public:
+        virtual ~IModuleExportInterface() { }
+};
+
+} // namespace scratchcpp::modularity

src/global/modularity/imodulesetup.h

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <string>
+
+namespace scratchcpp::modularity
+{
+
+class IModuleSetup
+{
+    public:
+        virtual ~IModuleSetup() { }
+
+        virtual std::string moduleName() const = 0;
+
+        virtual void registerExports() { }
+        virtual void initSettings() { }
+
+        virtual void onPreInit() { }
+        virtual void onInit() { }
+        virtual void onDeinit() { }
+        virtual void onDestroy() { }
+
+        virtual void onStartApp() { }
+};
+
+} // namespace scratchcpp::modularity

src/global/modularity/ioc.h

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "modulesioc.h"
+
+#define INJECT(Interface, getter)                                                                                                                                                                      \
+private:                                                                                                                                                                                               \
+    static inline std::shared_ptr<Interface> _##getter = nullptr;                                                                                                                                      \
+                                                                                                                                                                                                       \
+public:                                                                                                                                                                                                \
+    static std::shared_ptr<Interface> getter()                                                                                                                                                         \
+    {                                                                                                                                                                                                  \
+        if (!_##getter) {                                                                                                                                                                              \
+            _##getter = modularity::ioc()->resolve<Interface>();                                                                                                                                       \
+        }                                                                                                                                                                                              \
+        return _##getter;                                                                                                                                                                              \
+    }                                                                                                                                                                                                  \
+    static void set##getter(std::shared_ptr<Interface> impl)                                                                                                                                           \
+    {                                                                                                                                                                                                  \
+        _##getter = impl;                                                                                                                                                                              \
+    }
+
+namespace scratchcpp::modularity
+{
+
+inline ModulesIoC *ioc()
+{
+    return ModulesIoC::instance();
+}
+
+} // namespace scratchcpp::modularity

src/global/modularity/modulesioc.h

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <unordered_set>
+#include <vector>
+#include <memory>
+#include <cassert>
+#include "imoduleexportinterface.h"
+
+namespace scratchcpp::modularity
+{
+
+class ModulesIoC
+{
+    public:
+        static ModulesIoC *instance()
+        {
+            static ModulesIoC instance;
+            return &instance;
+        }
+
+        template<class I>
+        void registerExport(std::shared_ptr<I> instance)
+        {
+            // Remove old exports of this class
+            std::vector<std::shared_ptr<IModuleExportInterface>> toRemove;
+
+            for (auto ex : m_exports) {
+                std::shared_ptr<I> exCast = std::dynamic_pointer_cast<I>(ex);
+
+                if (exCast)
+                    toRemove.push_back(exCast);
+            }
+
+            for (auto ex : toRemove)
+                m_exports.erase(ex);
+
+            // Register the export
+            auto iface = std::dynamic_pointer_cast<IModuleExportInterface>(instance);
+            assert(m_exports.find(iface) == m_exports.end());
+
+            if (!iface) {
+                assert(false);
+                return;
+            }
+
+            m_exports.insert(iface);
+        }
+
+        template<class I>
+        std::shared_ptr<I> resolve() const
+        {
+            for (auto ex : m_exports) {
+                std::shared_ptr<I> exCast = std::dynamic_pointer_cast<I>(ex);
+                if (exCast)
+                    return exCast;
+            }
+
+            return nullptr;
+        }
+
+    private:
+        std::unordered_set<std::shared_ptr<IModuleExportInterface>> m_exports;
+};
+
+} // namespace scratchcpp::modularity

src/global/test/CMakeLists.txt

@@ -0,0 +1,9 @@
+set(MODULE_TEST_SRC
+    modularity.cpp
+    fakeexport.h
+    fakedependency.h
+    mocks/moduleexportinterfacemock.h
+    mocks/modulesetupmock.h
+)
+
+include(${PROJECT_SOURCE_DIR}/build/module_test.cmake)

src/global/test/fakedependency.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <modularity/imoduleexportinterface.h>
+
+namespace scratchcpp
+{
+
+class FakeDependency : MODULE_EXPORT_INTERFACE
+{ };
+
+} // namespace scratchcpp

src/global/test/fakeexport.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <modularity/imoduleexportinterface.h>
+#include <modularity/ioc.h>
+
+#include "fakedependency.h"
+
+namespace scratchcpp
+{
+
+class FakeExport : MODULE_EXPORT_INTERFACE
+{
+        INJECT(FakeDependency, dep);
+};
+
+} // namespace scratchcpp

src/global/test/mocks/moduleexportinterfacemock.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <modularity/imoduleexportinterface.h>
+
+namespace scratchcpp::modularity
+{
+
+class ModuleExportInterfaceMock : public IModuleExportInterface
+{ };
+
+} // namespace scratchcpp::modularity

src/global/test/mocks/modulesetupmock.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <modularity/imodulesetup.h>
+#include <gmock/gmock.h>
+
+namespace scratchcpp::modularity
+{
+
+class ModuleSetupMock : public IModuleSetup
+{
+    public:
+        MOCK_METHOD(std::string, moduleName, (), (const, override));
+
+        MOCK_METHOD(void, registerExports, (), (override));
+        MOCK_METHOD(void, initSettings, (), (override));
+
+        MOCK_METHOD(void, onPreInit, (), (override));
+        MOCK_METHOD(void, onInit, (), (override));
+        MOCK_METHOD(void, onDeinit, (), (override));
+        MOCK_METHOD(void, onDestroy, (), (override));
+
+        MOCK_METHOD(void, onStartApp, (), (override));
+};
+
+} // namespace scratchcpp::modularity