add DI

Author: 7bitcoder

Source/Library/CMakeLists.txt

@@ -1,6 +1,11 @@
-file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS *.cpp)
+#file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS *.cpp)
 
-add_library(SandboxLib ${SOURCES})
+add_library(SandboxLib 
+  LinkedList.cpp
+  Map.cpp
+  MemoryManager.cpp
+  DependencyInjector.cpp
+)
 
 target_include_directories(SandboxLib PUBLIC
   h

Source/Library/Date.cpp

@@ -1,5 +1,5 @@
-#include <chrono>
 #include "DetectOs.hpp"
+#include <chrono>
 
 // skip for linux for now, c++20 must be fully implemented for clang - linux
 #ifdef WINDOWS
@@ -219,6 +219,7 @@ namespace sd
     std::string Date::toString(const std::string &f) const { return std::format(f, ch::zt{timeZone(), timePoint()}); }
 
     Date Date::toUtcTimeZone() const { return Date{*this}.changeTimeZoneToUtc(); }
+
     Date Date::toLocalTimeZone() const { return Date{*this}.changeTimeZoneToLocal(); }
     Date Date::toDefaultTimeZone() const { return Date{*this}.changeTimeZoneToDefault(); }
     Date Date::toTimeZone(const std::string &tzName) const { return Date{*this}.changeTimeZone(tzName); }

Source/Library/DependencyInjector.cpp

@@ -0,0 +1,6 @@
+#include "DependencyInjector.hpp"
+
+namespace sd
+{
+
+}

Source/Library/Time.cpp

@@ -4,7 +4,6 @@
 #include <cmath>
 #include <tuple>
 
-
 #ifdef WINDOWS
 #include <format>
 

Source/Library/h/DependencyInjector.hpp

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+#include <vector>
+
+namespace sd
+{
+
+    class DependencyInjector
+    {
+      private:
+        template <class T> struct Constructor
+        {
+            T ctor;
+            Constructor(T ctor) : ctor(ctor) {}
+        };
+
+        struct IConstructionInfo
+        {
+            virtual std::type_index getTypeIndex() const = 0;
+
+            virtual const std::vector<std::type_index> &getParamsTypeIndexes() const = 0;
+
+            virtual void *construct(const std::vector<void *> &params) const = 0;
+
+            virtual ~IConstructionInfo() {}
+        };
+
+        template <class Type, class Param1> class ConstructionInfo final : public IConstructionInfo
+        {
+          private:
+            std::type_index _typeIndex = typeid(Type);
+            std::vector<std::type_index> _params;
+            Type *(*_ctor)(Param1 *);
+
+          public:
+            ConstructionInfo(Constructor<Type *(*)(Param1 *)> constructor)
+            {
+                _ctor = constructor.ctor;
+                _params = {typeid(Param1)};
+            }
+
+            std::type_index getTypeIndex() const { return _typeIndex; }
+
+            const std::vector<std::type_index> &getParamsTypeIndexes() const { return _params; };
+
+            void *construct(const std::vector<void *> &params) const { return (*_ctor)((Param1 *)params[0]); };
+        };
+
+      private:
+        std::unordered_map<std::type_index, std::unique_ptr<IConstructionInfo>> _registered;
+        std::unordered_map<std::type_index, void *> _objectsMap;
+
+      public:
+        template <class I, class T> void addSingeleton()
+        {
+            // todo check if T inherits from/implements I
+            auto cons = Constructor{T::constructor};
+            auto i = new ConstructionInfo(cons);
+            _registered.insert({typeid(I), std::unique_ptr<IConstructionInfo>(i)});
+        }
+
+        template <class I> I *get() { return (I *)get(typeid(I)); }
+
+        void build()
+        {
+            for (auto &objectToBuild : _registered)
+            {
+                auto &[index, constructionInfo] = objectToBuild;
+                if (!get(index))
+                {
+                    make(index, *constructionInfo);
+                }
+            }
+        }
+
+      private:
+        void *make(std::type_index typeIndex, IConstructionInfo &info)
+        {
+            std::vector<void *> params;
+            auto &indexes = info.getParamsTypeIndexes();
+            for (auto index : indexes)
+            {
+                if (auto object = get(index))
+                {
+                    params.push_back(object);
+                }
+                else if (auto constructionInfo = getRegistered(index))
+                {
+                    params.push_back(make(index, *constructionInfo));
+                }
+                else
+                {
+                    // todo
+                }
+            }
+            auto object = info.construct(params);
+            _objectsMap.insert({typeIndex, object});
+            return object;
+        }
+
+        void *get(std::type_index index)
+        {
+            auto pair = _objectsMap.find(index);
+            return pair != _objectsMap.end() ? pair->second : nullptr;
+        }
+
+        IConstructionInfo *getRegistered(std::type_index index)
+        {
+            auto pair = _registered.find(index);
+            return pair != _registered.end() ? pair->second.get() : nullptr;
+        }
+    };
+} // namespace sd

Tests/CMakeLists.txt

@@ -1,8 +1,12 @@
 
-file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS *.cpp)
+#file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS *.cpp)
 
 add_executable(Test
-    ${SOURCES}
+    RunTests.cpp
+    ListTest.cpp
+    MapTest.cpp
+    MemoryManagerTest.cpp
+    DependencyInjectorTest.cpp
 )
 
 target_link_libraries(Test 

Tests/DependencyInjectorTest.cpp

@@ -0,0 +1,39 @@
+#include <gtest/gtest.h>
+#include <iostream>
+#include <thread>
+
+#include "DependencyInjector.hpp"
+
+struct TestA
+{
+    static TestA *constructor() { return new TestA(); };
+};
+
+struct TestB
+{
+    static TestB *constructor(TestA *a) { return new TestB(); };
+};
+
+class DependencyInjector : public ::testing::Test
+{
+  protected:
+    sd::DependencyInjector di;
+
+    static void SetUpTestSuite() {}
+
+    DependencyInjector() {}
+
+    void SetUp() override {}
+
+    void TearDown() override {}
+
+    ~DependencyInjector() {}
+
+    static void TearDownTestSuite() {}
+};
+
+TEST_F(DependencyInjector, ExampleTest)
+{
+    di.addSingeleton<TestA, TestA>();
+    di.addSingeleton<TestB, TestB>();
+}