feat: tuple map bindings + lambda resolvers (#6)

* feat: use variant bindings in container's symbol map This support faster lookup speeds as we are no longer using `std::any`. * reduce test flake across platforms * update single_includes * fix: windows optimize copts * docs: remove old api * lower the bar a bit (speed test) * refactor: tuple >>> map + variant (for binding map) * remove unused include * only use container.template get... call when necessary * add consumed std types * fix: allow for duplicate symbol types + allow struct symbols * docs: refer to the containerless branch * test: use catch2 BENCHMARK * refactor: remove resolver classes * remove unused meta structs * refactor: cache/constant resolver lambdas * fix: codacy extra newline
mosure · Mar 21, 2021 · 5ff69ec · 5ff69ec
1 parent ad8ab97
commit 5ff69ec
Show file tree

Hide file tree

Showing 35 changed files with 744 additions and 509 deletions.
diff --git a/.bazelrc b/.bazelrc
@@ -1,3 +1,3 @@
-build:windows --copt="/std:c++17" --copt="/W4"
+build:windows --copt="/std:c++17" --copt="/W4" --copt="/O2"
 build:linux --copt="-std=c++17" --copt="-O3"
-build:macos --copt="-std=c++17"
+build:macos --copt="-std=c++17" --copt="-O3"
diff --git a/.gitignore b/.gitignore
@@ -33,3 +33,5 @@
 
 .vscode/
 bazel-*
+
+callgrind.out.*
diff --git a/BUILD b/BUILD
@@ -23,6 +23,7 @@ cc_library(
         "-Wall",
         "-Wextra",
         "-Wshadow",
+        "-Wunused",
     ],
     hdrs = glob([
         "include/**/*.hpp",

diff --git a/README.md b/README.md
@@ -13,6 +13,10 @@
 
 C++17 inversion of control and dependency injection container library.
 
+## Containerless Version
+
+See the [`containerless` branch](https://github.com/mosure/inversify-cpp/tree/containerless) for a static binding (containerless) version of the library.
+
 ## Features
 *   Constant, dynamic, and automatic resolvers
 *   Singleton, resolution (TODO), and unique scopes
@@ -71,6 +75,8 @@ namespace symbols {
 
 ```
 
+> Note: symbols which hold the same interface type may do so via structs which inherit inversify::Symbol
+
 #### Declare Classes and Dependencies
 
 ```cpp
@@ -135,9 +141,9 @@ Singleton scope dynamic bindings cache the first resolution of the binding.
 ```cpp
 
 container.bind<symbols::fizz>().toDynamicValue(
-    [](const inversify::Context& ctx) {
-        auto foo = ctx.container.get<symbols::foo>();
-        auto bar = ctx.container.get<symbols::bar>();
+    [](auto& ctx) {
+        auto foo = ctx.container.template get<symbols::foo>();
+        auto bar = ctx.container.template get<symbols::bar>();
 
         auto fizz = std::make_shared<Fizz>(foo, bar);
 
@@ -154,10 +160,10 @@ Dynamic bindings can be used to resolve factory functions.
 ```cpp
 
 container.bind<symbols::fizzFactory>().toDynamicValue(
-    [](const inversify::Context& ctx) {
+    [](auto& ctx) {
         return [&]() {
-            auto foo = ctx.container.get<symbols::foo>();
-            auto bar = ctx.container.get<symbols::bar>();
+            auto foo = ctx.container.template get<symbols::foo>();
+            auto bar = ctx.container.template get<symbols::bar>();
 
             auto fizz = std::make_shared<Fizz>(foo, bar);
 
@@ -209,12 +215,19 @@ Use the following to run tests:
 
 `bazel run test --enable_platform_specific_config`
 
-> Note: run the example app in a similar way: `bazel run example --enable_platform_specific_config`
+> Note: run the example app in a similar way: `bazel run example/simple --enable_platform_specific_config`
 
 ## TODOS
 *   More compile-time checks
 *   Resolution scope
 
+### Profiling
+
+Run the following to generate a callgrind file:
+
+*   `bazel run example/profiling --enable_platform_specific_config --compilation_mode=dbg -s`
+*   `valgrind --tool=callgrind --dump-instr=yes --simulate-cache=yes --collect-jumps=yes ./bazel-bin/example/profiling/profiling`
+
 ## Generating `single_include` Variant
 
 Run `python ./third_party/amalgamate/amalgamate.py -c ./third_party/amalgamate/config.json -s ./` from the root of the repository.

diff --git a/example/profiling/BUILD b/example/profiling/BUILD
@@ -0,0 +1,13 @@
+load("@rules_cc//cc:defs.bzl", "cc_binary")
+
+
+cc_binary(
+    name = "profiling",
+    srcs = [
+        "main.cpp",
+    ],
+    deps = [
+        "//:inversify",
+    ],
+    visibility = ["//visibility:public"]
+)
diff --git a/example/profiling/main.cpp b/example/profiling/main.cpp
@@ -0,0 +1,46 @@
+#include <iostream>
+
+#include <mosure/inversify.hpp>
+
+
+namespace inversify = mosure::inversify;
+
+using int_symbol = inversify::Symbol<int>;
+
+struct Service {
+    int val;
+
+    Service() : val(0) { }
+    Service(int val) : val(val) { }
+
+    void foo() {
+        std::cout << "hello: " << val << std::endl;
+    }
+};
+
+template <>
+struct inversify::Injectable<Service>
+    : inversify::Inject<
+        int_symbol
+    >
+{ };
+
+using test_symbol = inversify::Symbol<Service>;
+
+
+template <typename Container>
+void to_profile(Container& container) {
+    container.template get<test_symbol>().foo();
+}
+
+int main() {
+    inversify::Container<
+        int_symbol,
+        test_symbol
+    > container;
+
+    container.bind<int_symbol>().toConstantValue(3);
+    container.bind<test_symbol>().to<Service>();
+
+    to_profile(container);
+}
diff --git a/example/BUILD → example/simple/BUILD b/example/BUILD → example/simple/BUILD
@@ -2,7 +2,7 @@ load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library")
 
 
 cc_library(
-    name = "example_api",
+    name = "simple_api",
     hdrs = glob([
         "api/*.hpp",
         "src/*.hpp",
@@ -14,7 +14,7 @@ cc_library(
 )
 
 cc_library(
-    name = "example_src_hdrs",
+    name = "simple_src_hdrs",
     hdrs = glob([
         "src/*.hpp",
     ]),
@@ -25,13 +25,13 @@ cc_library(
 )
 
 cc_binary(
-    name = "example",
+    name = "simple",
     srcs = glob([
         "src/*.cpp",
     ]),
     deps = [
-        ":example_api",
-        ":example_src_hdrs",
+        ":simple_api",
+        ":simple_src_hdrs",
         "//:inversify",
     ],
     visibility = ["//visibility:public"]

diff --git a/example/api/logger.hpp → example/simple/api/logger.hpp b/example/api/logger.hpp → example/simple/api/logger.hpp
diff --git a/example/api/service.hpp → example/simple/api/service.hpp b/example/api/service.hpp → example/simple/api/service.hpp
diff --git a/example/api/settings.hpp → example/simple/api/settings.hpp b/example/api/settings.hpp → example/simple/api/settings.hpp
diff --git a/example/api/symbols.hpp → example/simple/api/symbols.hpp b/example/api/symbols.hpp → example/simple/api/symbols.hpp
diff --git a/example/src/logger.hpp → example/simple/src/logger.hpp b/example/src/logger.hpp → example/simple/src/logger.hpp
diff --git a/example/src/main.cpp → example/simple/src/main.cpp b/example/src/main.cpp → example/simple/src/main.cpp
@@ -11,7 +11,11 @@
 namespace inversify = mosure::inversify;
 
 int main() {
-    inversify::Container container;
+    inversify::Container<
+        symbols::logger,
+        symbols::service,
+        symbols::settings
+    > container;
 
     container.bind<symbols::logger>().to<Logger>().inSingletonScope();
     container.bind<symbols::service>().to<Service>();

diff --git a/example/src/mock_logger.hpp → example/simple/src/mock_logger.hpp b/example/src/mock_logger.hpp → example/simple/src/mock_logger.hpp
diff --git a/example/src/service.hpp → example/simple/src/service.hpp b/example/src/service.hpp → example/simple/src/service.hpp
diff --git a/example/src/settings.hpp → example/simple/src/settings.hpp b/example/src/settings.hpp → example/simple/src/settings.hpp
diff --git a/include/mosure/binding.hpp b/include/mosure/binding.hpp
@@ -1,56 +1,73 @@
 #pragma once
 
 #include <functional>
-#include <memory>
+#include <type_traits>
 
 #include <mosure/context.hpp>
 #include <mosure/factory.hpp>
 #include <mosure/resolver.hpp>
+#include <mosure/exceptions/resolution.hpp>
 
 
 namespace mosure::inversify {
 
-    template <typename T>
+    template <typename T, typename... SymbolTypes>
     class BindingScope {
         public:
             void inSingletonScope() {
-                resolver_ = std::make_shared<inversify::CachedResolver<T>>(resolver_);
+                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:
-            inversify::ResolverPtr<T> resolver_;
+            T cached_;
+            bool cached_set_ { false };
+            inversify::Factory<T, SymbolTypes...> factory_;
     };
 
-    template <typename T>
-    class BindingTo : public BindingScope<T> {
+    template <typename T, typename... SymbolTypes>
+    class BindingTo
+        : public BindingScope<T, SymbolTypes...>
+    {
         public:
             void toConstantValue(T&& value) {
-                this->resolver_ = std::make_shared<inversify::ConstantResolver<T>>(value);
+                this->factory_ = [val = std::move(value)](auto&) {
+                    return val;
+                };
             }
 
-            BindingScope<T>& toDynamicValue(inversify::Factory<T> factory) {
-                this->resolver_ = std::make_shared<inversify::DynamicResolver<T>>(factory);
+            BindingScope<T, SymbolTypes...>& toDynamicValue(inversify::Factory<T, SymbolTypes...>&& factory) {
+                this->factory_ = std::move(factory);
 
                 return *this;
             }
 
             template <typename U>
-            BindingScope<T>& to() {
-                this->resolver_ = std::make_shared<inversify::AutoResolver<T, U>>();
+            BindingScope<T, SymbolTypes...>& to() {
+                this->factory_ = inversify::get_auto_resolver<T, U, SymbolTypes...>();
 
                 return *this;
             }
     };
 
-    template <typename T>
-    class Binding : public BindingTo<T> {
+    template <typename T, typename... SymbolTypes>
+    class Binding
+        : public BindingTo<typename T::value, SymbolTypes...>
+    {
         public:
-            inline T resolve(const Context& context) const {
-                if (!this->resolver_) {
-                    throw inversify::exceptions::ResolutionException("inversify::Resolver not found. Malformed binding.");
-                }
-
-                return this->resolver_->resolve(context);
+            inline typename T::value resolve(const inversify::Context<SymbolTypes...>& context) {
+                return this->factory_(context);
             }
     };
 

diff --git a/include/mosure/container.hpp b/include/mosure/container.hpp
@@ -1,31 +1,64 @@
 #pragma once
 
+#include <tuple>
+
 #include <mosure/binding.hpp>
 #include <mosure/context.hpp>
 #include <mosure/interfaces/icontainer.hpp>
+#include <mosure/meta.hpp>
 
 
 namespace mosure::inversify {
 
-    template <typename Symbol>
-    struct BindingLookup {
-        inline static inversify::Binding<typename Symbol::value> binding {};
-    };
-
-    class Container : public inversify::IContainer<Container> {
+    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>& bind() {
-                return BindingLookup<T>::binding;
+            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() const {
-                return BindingLookup<T>::binding.resolve(context_);
+            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:
-            inversify::Context context_ { *this };
+            BindingMap bindings_ {};
+            inversify::Context<SymbolTypes...> context_ { *this };
     };
 
 }
diff --git a/include/mosure/context.hpp b/include/mosure/context.hpp
@@ -5,10 +5,12 @@
 
 namespace mosure::inversify {
 
+    template <typename... SymbolTypes>
     class Container;
 
+    template <typename... SymbolTypes>
     struct Context {
-        const inversify::IContainer<Container>& container;
+        inversify::IContainer<Container, SymbolTypes...>& container;
     };
 
 }
diff --git a/include/mosure/factory.hpp b/include/mosure/factory.hpp
@@ -7,7 +7,7 @@
 
 namespace mosure::inversify {
 
-    template <typename T>
-    using Factory = std::function<T(const inversify::Context&)>;
+    template <typename T, typename... SymbolTypes>
+    using Factory = std::function<T(const inversify::Context<SymbolTypes...>&)>;
 
 }