Streamline injector definitions

scravy · scravy · commit bb36a222a478 · 2019-04-04T11:47:57.000+02:00
Signed-off-by: Julian Fleischer &lt;julian@thirdhash.com&gt;
diff --git a/src/dependency_injector.h b/src/dependency_injector.h
@@ -149,15 +149,15 @@ class UnregisteredDependenciesError : public InjectionError {
   mutable std::string m_error_message;
 
  public:
-  std::vector<std::pair<std::string, std::type_index>> m_missingDependencies;
+  std::vector<std::pair<std::string, std::type_index>> m_missing_dependencies;
   explicit UnregisteredDependenciesError(
       std::vector<std::pair<std::string, std::type_index>>
           &&missingDependencies)
-      : m_missingDependencies(std::move(missingDependencies)){};
+      : m_missing_dependencies(std::move(missingDependencies)){};
   const char *what() const noexcept override {
     if (m_error_message.empty()) {
       std::ostringstream s;
-      for (const auto &missingDependency : m_missingDependencies) {
+      for (const auto &missingDependency : m_missing_dependencies) {
         tfm::format(s, "%s requires %s, but that is not a known component\n",
                     missingDependency.first, missingDependency.second.name());
       }
@@ -236,6 +236,9 @@ class Injector {
   // they need access to the injector (hence it's passed in).
   using Method = void (*)(InjectorType *);
 
+  // a function pointer to a function that takes an Injector is its first
+  // argument and creates a pointer to an unmanaged component from it. The
+  // injector will take ownership of that pointer.
   template <typename T>
   using Factory = T *(*)(InjectorType *);
 
@@ -252,7 +255,7 @@ class Injector {
   };
 
   std::map<std::type_index, Component> m_components;
-  std::vector<std::type_index> m_destructionOrder;
+  std::vector<std::type_index> m_destruction_order;
 
   static std::vector<void *> GatherDependencies(I *injector,
                                                 const Component &component) {
@@ -298,8 +301,7 @@ class Injector {
   template <typename T>
   struct Registrator {
     template <typename... Deps>
-    static Dependency<T> Register(I *injector, const std::string &name,
-                                  Method init) {
+    static Dependency<T> Register(I *const injector, const std::string &name, Method init) {
       std::type_index typeIndex(typeid(T));
       Component component;
       component.m_name = name;
@@ -314,7 +316,7 @@ class Injector {
 
   template <typename ComponentType>
   struct Initializer {
-    static Component &GetComponent(I *injector) {
+    static Component &GetComponent(I *const injector) {
       return injector->m_components[typeid(ComponentType)];
     }
     template <typename... Args>
@@ -330,13 +332,18 @@ class Injector {
       }
     };
     struct Unmanaged {
-      template <typename T>
-      static ComponentType *Init(I *injector, Factory<T> factory) {
+      static ComponentType *Init(I *const injector, ComponentType *const pointer) {
         auto &component = GetComponent(injector);
-        T *const ptr = factory(injector);
-        component.m_instance = ptr;
+        component.m_instance = pointer;
         component.m_deleter = nullptr;
-        return ptr;
+        return pointer;
+      }
+      static ComponentType *Init(I *const injector, Factory<ComponentType> factory) {
+        auto &component = GetComponent(injector);
+        ComponentType *const pointer = factory(injector);
+        component.m_instance = pointer;
+        component.m_deleter = nullptr;
+        return pointer;
       }
     };
   };
@@ -404,7 +411,7 @@ class Injector {
       }
     }
     std::reverse(initializationOrder.begin(), initializationOrder.end());
-    m_destructionOrder = std::move(initializationOrder);
+    m_destruction_order = std::move(initializationOrder);
     m_stopped.clear();
   }
 
@@ -414,7 +421,7 @@ class Injector {
       return;
     }
     std::vector<ComponentError> errors;
-    for (const std::type_index &component_type : m_destructionOrder) {
+    for (const std::type_index &component_type : m_destruction_order) {
       if (m_components[component_type].m_stopper) {
         try {
           m_components[component_type].m_stopper(static_cast<I *>(this));
@@ -439,7 +446,7 @@ class Injector {
     } catch (StoppingComponentsError &) {
       // see https://stackoverflow.com/a/130123/471478
     }
-    for (const std::type_index &componentType : m_destructionOrder) {
+    for (const std::type_index &componentType : m_destruction_order) {
       if (m_components[componentType].m_deleter) {
         m_components[componentType].m_deleter(static_cast<I *>(this));
       }
diff --git a/src/injector.h b/src/injector.h
@@ -35,14 +35,11 @@
 
 class UnitEInjector : public Injector<UnitEInjector> {
 
-  static ::ArgsManager *GetGlobalArgs(UnitEInjector *) { return &gArgs; }
-  UNMANAGED_COMPONENT(ArgsManager, ::ArgsManager, GetGlobalArgs)
+  UNMANAGED_COMPONENT(ArgsManager, ::ArgsManager, &gArgs)
 
-  static blockchain::Behavior *GetGlobalBehavior(UnitEInjector *) { return &blockchain::Behavior::GetGlobal(); }
-  UNMANAGED_COMPONENT(BlockchainBehavior, blockchain::Behavior, GetGlobalBehavior)
+  UNMANAGED_COMPONENT(BlockchainBehavior, blockchain::Behavior, &blockchain::Behavior::GetGlobal())
 
-  static UnitEInjectorConfiguration *GetInjectorConfiguration(UnitEInjector *injector) { return &injector->m_config; }
-  UNMANAGED_COMPONENT(InjectorConfiguration, UnitEInjectorConfiguration, GetInjectorConfiguration)
+  UNMANAGED_COMPONENT(InjectorConfiguration, UnitEInjectorConfiguration, [](UnitEInjector *i) { return &i->m_config; })
 
   COMPONENT(Settings, ::Settings, Settings::New,
             ::ArgsManager,
