From 7226f236dca196b0472c3cd7d8161c6013c73da3 Mon Sep 17 00:00:00 2001
From: mosure <mosure@wisc.edu>
Date: Mon, 12 Apr 2021 22:06:00 -0700
Subject: [PATCH] store inspection injectable dependencies as type alias

---
 include/mosure/injectable.hpp       |   2 +-
 include/mosure/resolver.hpp         |   2 +-
 single_include/mosure/inversify.hpp | 700 ++++++++++++++++++----------
 3 files changed, 451 insertions(+), 253 deletions(-)

diff --git a/include/mosure/injectable.hpp b/include/mosure/injectable.hpp
index 4ba297b..fd04c15 100644
--- a/include/mosure/injectable.hpp
+++ b/include/mosure/injectable.hpp
@@ -17,7 +17,7 @@ struct Inject {
     );
 
 #ifdef INVERSIFY_BINDING_INSPECTION
-    inline static std::tuple<Dependencies...> dependencies;
+    using value = std::tuple<Dependencies...>;
 #endif
 
     template <typename... SymbolTypes>
diff --git a/include/mosure/resolver.hpp b/include/mosure/resolver.hpp
index f47666f..5ba5211 100644
--- a/include/mosure/resolver.hpp
+++ b/include/mosure/resolver.hpp
@@ -159,7 +159,7 @@ class AutoResolverBase
             return dep_tuple;
         };
 
-        return std::apply(unroll, inversify::Injectable<U>::dependencies);
+        return std::apply(unroll, typename inversify::Injectable<U>::value{});
     }
 #endif
 };
diff --git a/single_include/mosure/inversify.hpp b/single_include/mosure/inversify.hpp
index b29a164..dc58f30 100644
--- a/single_include/mosure/inversify.hpp
+++ b/single_include/mosure/inversify.hpp
@@ -58,15 +58,15 @@ SOFTWARE.
 
 namespace mosure::inversify {
 
-    template <typename Interface>
-    struct Symbol {
-        static_assert(
-            !std::is_abstract<Interface>(),
-            "inversify::Container cannot bind/get abstract class value (use a smart pointer instead)."
-        );
+template <typename Interface>
+struct Symbol {
+    static_assert(
+        !std::is_abstract<Interface>(),
+        "inversify::Container cannot bind/get abstract class value (use a smart pointer instead)."
+    );
 
-        using value = Interface;
-    };
+    using value = Interface;
+};
 
 }
 
@@ -74,32 +74,32 @@ namespace mosure::inversify {
 
 namespace mosure::inversify {
 
-    template <
-        typename T,
-        typename... SymbolTypes
-    >
-    class BindingTo;
-
-    template <
-        template <typename...> class Implementation,
-        typename... SymbolTypes
-    >
-    class IContainer {
-        public:
-            template <typename T>
-            inversify::BindingTo<typename T::value, SymbolTypes...>& bind() {
-                auto crtpImplementation = static_cast<Implementation<SymbolTypes...> *>(this);
-
-                return crtpImplementation->template bind<T>();
-            }
-
-            template <typename T>
-            typename T::value get() {
-                auto crtpImplementation = static_cast<Implementation<SymbolTypes...> *>(this);
-
-                return crtpImplementation->template get<T>();
-            }
-    };
+template <
+    typename T,
+    typename... SymbolTypes
+>
+class BindingTo;
+
+template <
+    template <typename...> class Implementation,
+    typename... SymbolTypes
+>
+class IContainer {
+public:
+    template <typename T>
+    inversify::BindingTo<typename T::value, SymbolTypes...>& bind() {
+        auto crtpImplementation = static_cast<Implementation<SymbolTypes...> *>(this);
+
+        return crtpImplementation->template bind<T>();
+    }
+
+    template <typename T>
+    typename T::value get() {
+        auto crtpImplementation = static_cast<Implementation<SymbolTypes...> *>(this);
+
+        return crtpImplementation->template get<T>();
+    }
+};
 
 }
 
@@ -107,13 +107,13 @@ namespace mosure::inversify {
 
 namespace mosure::inversify {
 
-    template <typename... SymbolTypes>
-    class Container;
+template <typename... SymbolTypes>
+class Container;
 
-    template <typename... SymbolTypes>
-    struct Context {
-        inversify::IContainer<Container, SymbolTypes...>& container;
-    };
+template <typename... SymbolTypes>
+struct Context {
+    inversify::IContainer<Container, SymbolTypes...>& container;
+};
 
 }
 
@@ -128,18 +128,25 @@ namespace mosure::inversify {
 
 namespace mosure::inversify {
 
-    template <typename T, typename... SymbolTypes>
-    using Factory = std::function<T(const inversify::Context<SymbolTypes...>&)>;
+template <typename T, typename... SymbolTypes>
+using Factory = std::function<T(const inversify::Context<SymbolTypes...>&)>;
 
 }
 
 // #include <mosure/resolver.hpp>
 
 
+#include <atomic>
 #include <memory>
 #include <tuple>
 #include <type_traits>
 
+#ifdef INVERSIFY_BINDING_INSPECTION
+#include <string>
+#include <typeinfo>
+#include <vector>
+#endif
+
 // #include <mosure/context.hpp>
 
 // #include <mosure/factory.hpp>
@@ -165,211 +172,402 @@ namespace mosure::inversify {
 
 namespace mosure::inversify::meta {
 
-    template<
-        typename T,
-        typename... Types
-    >
-    inline constexpr bool contains_v = std::disjunction_v<
-        std::is_same<T, Types>...
-    >;
+template<
+    typename T,
+    typename... Types
+>
+inline constexpr bool contains_v = std::disjunction_v<
+    std::is_same<T, Types>...
+>;
 
 
-    template <typename... Args>
-    struct is_empty : std::false_type { };
+template <typename... Args>
+struct is_empty : std::false_type { };
 
-    template<>
-    struct is_empty<> : std::true_type { };
+template<>
+struct is_empty<> : std::true_type { };
 
-    template <typename... Args>
-    inline constexpr bool is_empty_v = is_empty<Args...>::value;
+template <typename... Args>
+inline constexpr bool is_empty_v = is_empty<Args...>::value;
 
 
-    template <
-        typename T,
-        template <typename...> typename Template
-    >
-    struct is_specialization : std::false_type { };
+template <
+    typename T,
+    template <typename...> typename Template
+>
+struct is_specialization : std::false_type { };
 
-    template <
-        template <typename...> typename Template,
-        typename... Args
-    >
-    struct is_specialization<Template<Args...>, Template> : std::true_type { };
+template <
+    template <typename...> typename Template,
+    typename... Args
+>
+struct is_specialization<Template<Args...>, Template> : std::true_type { };
 
 
-    template <typename T>
-    struct is_unique_ptr : std::false_type { };
+template <typename ...Types>
+inline constexpr bool valid_symbol_types_v = std::conjunction_v<
+    meta::is_specialization<Types, inversify::Symbol>...
+> || std::conjunction_v<
+    std::is_base_of<inversify::Symbol<typename Types::value>, Types>...
+>;
 
-    template <
-        typename T,
-        typename D
-    >
-    struct is_unique_ptr<std::unique_ptr<T, D>> : std::true_type { };
+}
 
-    template <typename T>
-    struct is_shared_ptr : std::false_type { };
 
-    template <typename T>
-    struct is_shared_ptr<std::shared_ptr<T>> : std::true_type { };
 
+namespace mosure::inversify {
 
-    template <typename ...Types>
-    inline constexpr bool valid_symbol_types_v = std::conjunction_v<
-        meta::is_specialization<Types, inversify::Symbol>...
-    > || std::conjunction_v<
-        std::is_base_of<inversify::Symbol<typename Types::value>, Types>...
-    >;
+template <typename... Dependencies>
+struct Inject {
+    static_assert(
+        meta::valid_symbol_types_v<Dependencies...>,
+        "inversify::Injectable dependencies must be of type inversify::Symbol"
+    );
+
+#ifdef INVERSIFY_BINDING_INSPECTION
+    using value = std::tuple<Dependencies...>;
+#endif
+
+    template <typename... SymbolTypes>
+    inline static auto resolve(const inversify::Context<SymbolTypes...>& context) {
+        return std::make_tuple(context.container.template get<Dependencies>()...);
+    }
+};
+
+template <typename Implementation, typename Inject = inversify::Inject<>>
+struct Injectable: Inject { };
 
 }
 
+// #include <mosure/exceptions/resolution.hpp>
 
 
-namespace mosure::inversify {
+#include <stdexcept>
+#include <string>
 
-    template <typename... Dependencies>
-    struct Inject {
-        static_assert(
-            meta::valid_symbol_types_v<Dependencies...>,
-            "inversify::Injectable dependencies must be of type inversify::Symbol"
-        );
 
-        template <typename... SymbolTypes>
-        inline static auto resolve(const inversify::Context<SymbolTypes...>& context) {
-            return std::make_tuple(context.container.template get<Dependencies>()...);
-        }
-    };
+namespace mosure::inversify::exceptions {
 
-    template <typename Implementation, typename Inject = inversify::Inject<>>
-    struct Injectable: Inject { };
+struct ResolutionException : public std::runtime_error {
+    explicit ResolutionException(const std::string& msg) : std::runtime_error(msg) { }
+};
 
 }
 
-// #include <mosure/meta.hpp>
-
 
 
 namespace mosure::inversify {
 
-    template <
-        typename T,
-        typename U,
-        typename... SymbolTypes
-    >
-    inline static inversify::Factory<T, SymbolTypes...> get_auto_resolver() {
-        if constexpr (meta::is_unique_ptr<T>::value) {
-            return [](const inversify::Context<SymbolTypes...>& context) {
-                auto expansion = [](auto&& ... deps){
-                    return std::make_unique<U>(deps...);
-                };
-
-                return std::apply(
-                    expansion,
-                    std::move(
-                        inversify::Injectable<U>::resolve(context)
-                    )
-                );
-            };
-        } else if constexpr (meta::is_shared_ptr<T>::value) {
-            return [](const inversify::Context<SymbolTypes...>& context) {
-                auto expansion = [](auto&& ... deps){
-                    return std::make_shared<U>(deps...);
-                };
-
-                return std::apply(
-                    expansion,
-                    std::move(
-                        inversify::Injectable<U>::resolve(context)
-                    )
-                );
-            };
-        } else {
-            return [](const inversify::Context<SymbolTypes...>& context) {
-                return std::make_from_tuple<U>(
-                    inversify::Injectable<U>::resolve(context)
-                );
-            };
-        }
+#ifdef INVERSIFY_BINDING_INSPECTION
+template <typename Symbol>
+struct Dependency {
+    using symbol = Symbol;
+
+    operator bool() { return dependent; }
+
+    bool dependent;
+};
+
+template <typename... SymbolTypes>
+class DependencyTuple {
+public:
+    template <typename Symbol>
+    auto get() {
+        return std::get<Dependency<Symbol>>(values);
     }
-}
 
-// #include <mosure/exceptions/resolution.hpp>
+    template <typename Symbol>
+    void set(bool value) {
+        std::get<Dependency<Symbol>>(values).dependent = value;
+    }
 
+    std::tuple<
+        inversify::Dependency<
+            SymbolTypes
+        >...
+    > values;
+};
+#endif
 
-#include <stdexcept>
-#include <string>
 
+template <
+    typename T,
+    typename... SymbolTypes
+>
+class Resolver {
+public:
+    inline virtual T resolve(const inversify::Context<SymbolTypes...>&) = 0;
 
-namespace mosure::inversify::exceptions {
+#ifdef INVERSIFY_BINDING_INSPECTION
+    inline virtual std::string getResolverLabel() const = 0;
 
-    struct ResolutionException : public std::runtime_error {
-        explicit ResolutionException(const std::string& msg) : std::runtime_error(msg) { }
+    inline virtual std::string getImplementationLabel() const {
+        return typeid(T).name();
     };
 
+    inline virtual inversify::DependencyTuple<SymbolTypes...> getDependencies() const {
+        return DependencyTuple<SymbolTypes...>{};
+    }
+#endif
+};
+
+template <
+    typename T,
+    typename... SymbolTypes
+>
+using ResolverPtr = std::shared_ptr<Resolver<T, SymbolTypes...>>;
+
+
+template <
+    typename T,
+    typename... SymbolTypes
+>
+class ConstantResolver
+    : public Resolver<T, SymbolTypes...> {
+public:
+    explicit ConstantResolver(T value) : value_(value) { }
+
+    inline T resolve(const inversify::Context<SymbolTypes...>&) override {
+        return value_;
+    }
+
+#ifdef INVERSIFY_BINDING_INSPECTION
+    inline virtual std::string getResolverLabel() const override {
+        return "constant";
+    }
+#endif
+
+private:
+    T value_;
+};
+
+
+template <
+    typename T,
+    typename... SymbolTypes
+>
+class DynamicResolver
+    : public Resolver<T, SymbolTypes...> {
+public:
+    explicit DynamicResolver(inversify::Factory<T, SymbolTypes...> factory) : factory_(factory) { }
+
+    inline T resolve(const inversify::Context<SymbolTypes...>& context) override {
+        return factory_(context);
+    }
+
+#ifdef INVERSIFY_BINDING_INSPECTION
+    inline virtual std::string getResolverLabel() const override {
+        return "dynamic";
+    }
+#endif
+
+private:
+    inversify::Factory<T, SymbolTypes...> factory_;
+};
+
+
+template <typename... Args>
+class AutoResolver;
+
+template <
+    typename T,
+    typename U,
+    typename... SymbolTypes
+>
+class AutoResolverBase
+    : public Resolver<T, SymbolTypes...> {
+public:
+#ifdef INVERSIFY_BINDING_INSPECTION
+    inline virtual std::string getResolverLabel() const override {
+        return "auto";
+    }
+
+    inline virtual std::string getImplementationLabel() const override {
+        return typeid(U).name();
+    }
+
+    inline virtual inversify::DependencyTuple<SymbolTypes...> getDependencies() const {
+        auto unroll = [](auto&&... deps) {
+            DependencyTuple<SymbolTypes...> dep_tuple;
+
+            auto enable_dep = [&dep_tuple](auto dep) {
+                dep_tuple.template set<decltype(dep)>(true);
+            };
+            (enable_dep(deps), ...);
+
+            return dep_tuple;
+        };
+
+        return std::apply(unroll, typename inversify::Injectable<U>::value{});
+    }
+#endif
+};
+
+
+template <
+    typename T,
+    typename U,
+    typename... SymbolTypes
+>
+class AutoResolver<T, U, SymbolTypes...>
+    : public AutoResolverBase<T, U, SymbolTypes...> {
+public:
+    inline virtual T resolve(const inversify::Context<SymbolTypes...>& context) override {
+        return std::make_from_tuple<U>(
+            inversify::Injectable<U>::template resolve<SymbolTypes...>(context)
+        );
+    }
+};
+
+
+// unique_ptr specialization
+template <
+    typename T,
+    typename U,
+    typename... SymbolTypes
+>
+class AutoResolver<std::unique_ptr<T>, U, SymbolTypes...>
+    : public AutoResolverBase<std::unique_ptr<T>, U, SymbolTypes...> {
+public:
+    inline std::unique_ptr<T> resolve(const inversify::Context<SymbolTypes...>& context) override {
+        auto expansion = [&context](auto&& ... deps){
+            return std::make_unique<U>(deps...);
+        };
+
+        return std::apply(
+            expansion,
+            std::move(
+                inversify::Injectable<U>::template resolve<SymbolTypes...>(context)
+            )
+        );
+    }
+};
+
+
+// shared_ptr specialization
+template <
+    typename T,
+    typename U,
+    typename... SymbolTypes
+>
+class AutoResolver<std::shared_ptr<T>, U, SymbolTypes...>
+    : public AutoResolverBase<std::shared_ptr<T>, U, SymbolTypes...> {
+public:
+    inline std::shared_ptr<T> resolve(const inversify::Context<SymbolTypes...>& context) override {
+        auto expansion = [&context](auto&& ... deps){
+            return std::make_shared<U>(deps...);
+        };
+
+        return std::apply(
+            expansion,
+            std::move(
+                inversify::Injectable<U>::template resolve<SymbolTypes...>(context)
+            )
+        );
+    }
+};
+
+
+template <
+    typename T,
+    typename... SymbolTypes
+>
+class CachedResolver
+    : public Resolver<T, SymbolTypes...> {
+static_assert(
+    std::is_copy_constructible_v<T>,
+    "inversify::CachedResolver requires a copy constructor. Are you caching a unique_ptr?"
+);
+
+public:
+    explicit CachedResolver(ResolverPtr<T, SymbolTypes...> parent) : parent_(parent) { }
+
+    inline T resolve(const inversify::Context<SymbolTypes...>& context) override {
+        if (!hasCached_) {
+            hasCached_ = true;
+            cached_ = parent_->resolve(context);
+        }
+
+        return cached_;
+    }
+
+#ifdef INVERSIFY_BINDING_INSPECTION
+    inline virtual std::string getResolverLabel() const override {
+        return std::string("cached - ") + parent_->getResolverLabel();
+    }
+
+    inline virtual std::string getImplementationLabel() const override {
+        return parent_->getImplementationLabel();
+    }
+#endif
+
+private:
+    T cached_;
+    std::atomic<bool> hasCached_ { false };
+    ResolverPtr<T, SymbolTypes...> parent_;
+};
+
 }
 
+// #include <mosure/exceptions/resolution.hpp>
+
 
 
 namespace mosure::inversify {
 
-    template <typename T, typename... SymbolTypes>
-    class BindingScope {
-        public:
-            void inSingletonScope() {
-                static_assert(
-                    std::is_copy_constructible<T>::value,
-                    "inversify::BindingScope singleton must have copy constructor"
-                );
-
-                this->factory_ = [this, factory = std::move(factory_)](auto& context) {
-                    if (!this->cached_set_) {
-                        this->cached_ = factory(context);
-                        this->cached_set_ = true;
-                    }
-
-                    return this->cached_;
-                };
-            }
-
-        protected:
-            T cached_;
-            bool cached_set_ { false };
-            inversify::Factory<T, SymbolTypes...> factory_;
-    };
+template <typename T, typename... SymbolTypes>
+class BindingScope {
+public:
+    void inSingletonScope() {
+        resolver_ = std::make_shared<inversify::CachedResolver<T, SymbolTypes...>>(resolver_);
+    }
 
-    template <typename T, typename... SymbolTypes>
-    class BindingTo
-        : public BindingScope<T, SymbolTypes...>
-    {
-        public:
-            void toConstantValue(T&& value) {
-                this->factory_ = [val = std::move(value)](auto&) {
-                    return val;
-                };
-            }
-
-            BindingScope<T, SymbolTypes...>& toDynamicValue(inversify::Factory<T, SymbolTypes...>&& factory) {
-                this->factory_ = std::move(factory);
-
-                return *this;
-            }
-
-            template <typename U>
-            BindingScope<T, SymbolTypes...>& to() {
-                this->factory_ = inversify::get_auto_resolver<T, U, SymbolTypes...>();
-
-                return *this;
-            }
-    };
+#ifdef INVERSIFY_BINDING_INSPECTION
+    auto getResolver() const {
+        return resolver_;
+    }
+#endif
+
+protected:
+    inversify::ResolverPtr<T, SymbolTypes...> resolver_;
+};
+
+template <typename T, typename... SymbolTypes>
+class BindingTo
+    : public BindingScope<T, SymbolTypes...>
+{
+public:
+    void toConstantValue(T&& value) {
+        this->resolver_ = std::make_shared<inversify::ConstantResolver<T, SymbolTypes...>>(value);
+    }
 
-    template <typename T, typename... SymbolTypes>
-    class Binding
-        : public BindingTo<typename T::value, SymbolTypes...>
-    {
-        public:
-            inline typename T::value resolve(const inversify::Context<SymbolTypes...>& context) {
-                return this->factory_(context);
-            }
-    };
+    BindingScope<T, SymbolTypes...>& toDynamicValue(inversify::Factory<T, SymbolTypes...>&& factory) {
+        this->resolver_ = std::make_shared<inversify::DynamicResolver<T, SymbolTypes...>>(factory);
+
+        return *this;
+    }
+
+    template <typename U>
+    BindingScope<T, SymbolTypes...>& to() {
+        this->resolver_ = std::make_shared<inversify::AutoResolver<T, U, SymbolTypes...>>();
+
+        return *this;
+    }
+};
+
+template <typename T, typename... SymbolTypes>
+class Binding
+    : public BindingTo<typename T::value, SymbolTypes...>
+{
+public:
+    inline typename T::value resolve(const inversify::Context<SymbolTypes...>& context) {
+        if (!this->resolver_) {
+            throw inversify::exceptions::ResolutionException("inversify::Resolver not found. Malformed binding.");
+        }
+
+        return this->resolver_->resolve(context);
+    }
+};
 
 }
 
@@ -390,56 +588,56 @@ namespace mosure::inversify {
 
 namespace mosure::inversify {
 
-    template <typename... SymbolTypes>
-    class Container
-        : public inversify::IContainer<Container, SymbolTypes...> 
-    {
-        public:
-            static_assert(
-                meta::valid_symbol_types_v<SymbolTypes...>,
-                "inversify::Container symbols must be of type inversify::Symbol"
-            );
-
-            static_assert(
-                !meta::is_empty_v<SymbolTypes...>,
-                "inversify::Container must register at least one symbol"
-            );
-
-            using BindingMap = std::tuple<
-                inversify::Binding<
-                    SymbolTypes,
-                    SymbolTypes...
-                >...
-            >;
-
-            template <typename T>
-            inline inversify::BindingTo<typename T::value, SymbolTypes...>& bind() {
-                static_assert(
-                    meta::contains_v<T, SymbolTypes...>,
-                    "inversify::Container symbol not registered"
-                );
-
-                return std::get<
-                    inversify::Binding<T, SymbolTypes...>
-                >(bindings_);
-            }
-
-            template <typename T>
-            inline typename T::value get() {
-                static_assert(
-                    meta::contains_v<T, SymbolTypes...>,
-                    "inversify::Container symbol not registered"
-                );
-
-                return std::get<
-                    inversify::Binding<T, SymbolTypes...>
-                >(bindings_).resolve(context_);
-            }
-
-        private:
-            BindingMap bindings_ {};
-            inversify::Context<SymbolTypes...> context_ { *this };
-    };
+template <typename... SymbolTypes>
+class Container
+    : public inversify::IContainer<Container, SymbolTypes...> 
+{
+public:
+    static_assert(
+        meta::valid_symbol_types_v<SymbolTypes...>,
+        "inversify::Container symbols must be of type inversify::Symbol"
+    );
+
+    static_assert(
+        !meta::is_empty_v<SymbolTypes...>,
+        "inversify::Container must register at least one symbol"
+    );
+
+    using BindingMap = std::tuple<
+        inversify::Binding<
+            SymbolTypes,
+            SymbolTypes...
+        >...
+    >;
+
+    template <typename T>
+    inline inversify::BindingTo<typename T::value, SymbolTypes...>& bind() {
+        static_assert(
+            meta::contains_v<T, SymbolTypes...>,
+            "inversify::Container symbol not registered"
+        );
+
+        return std::get<
+            inversify::Binding<T, SymbolTypes...>
+        >(bindings_);
+    }
+
+    template <typename T>
+    inline typename T::value get() {
+        static_assert(
+            meta::contains_v<T, SymbolTypes...>,
+            "inversify::Container symbol not registered"
+        );
+
+        return std::get<
+            inversify::Binding<T, SymbolTypes...>
+        >(bindings_).resolve(context_);
+    }
+
+private:
+    BindingMap bindings_ {};
+    inversify::Context<SymbolTypes...> context_ { *this };
+};
 
 }