mosure · mosure · Feb 14, 2021 · Jan 25, 2021
diff --git a/README.md b/README.md
@@ -60,14 +60,13 @@ using IFizzPtr = std::unique_ptr<IFizz>;
 ```cpp
 
 namespace symbols {
-    inline const inversify::Symbol foo { "Foo" };
-    inline const inversify::Symbol bar { "Bar" };
-    inline const inversify::Symbol fizz { "Fizz" };
-    inline const inversify::Symbol fizzFactory { "FizzFactory" };
-
-    inline const inversify::Symbol autoFizz { "AutoFizz" };
-    inline const inversify::Symbol autoFizzUnique { "AutoFizzUnique" };
-    inline const inversify::Symbol autoFizzShared { "AutoFizzShared" };
+    inline extern inversify::Symbol<int> foo {};
+    inline extern inversify::Symbol<double> bar {};
+    inline extern inversify::Symbol<IFizzPtr> fizz {};
+    inline extern inversify::Symbol<std::function<IFizzPtr()>> fizzFactory {};
+
+    inline extern inversify::Symbol<IFizzUniquePtr> autoFizzUnique {};
+    inline extern inversify::Symbol<IFizzSharedPtr> autoFizzShared {};
 }
 
 ```
@@ -97,8 +96,8 @@ struct Fizz : IFizz {
 };
 
 inline static auto injectFizz = inversify::Injectable<Fizz>::inject(
-    inversify::Inject<int>(symbols::foo),
-    inversify::Inject<double>(symbols::bar)
+    symbols::foo,
+    symbols::bar
 );
 
 ```
@@ -107,7 +106,7 @@ inline static auto injectFizz = inversify::Injectable<Fizz>::inject(
 
 ```cpp
 
-inversify::Container container {};
+inversify::Container container;
 
 ```
 
@@ -117,8 +116,8 @@ Constant bindings are always singletons.
 
 ```cpp
 
-container.bind<int>(symbols::foo).toConstantValue(10);
-container.bind<double>(symbols::bar).toConstantValue(1.618);
+container.bind(symbols::foo).toConstantValue(10);
+container.bind(symbols::bar).toConstantValue(1.618);
 
 ```
 
@@ -132,10 +131,10 @@ Singleton scope dynamic bindings cache the first resolution of the binding.
 
 ```cpp
 
-container.bind<IFizzPtr>(symbols::fizz).toDynamicValue(
+container.bind(symbols::fizz).toDynamicValue(
     [](const inversify::Context& ctx) {
-        auto foo = ctx.container.get<int>(symbols::foo);
-        auto bar = ctx.container.get<double>(symbols::bar);
+        auto foo = ctx.container.get(symbols::foo);
+        auto bar = ctx.container.get(symbols::bar);
 
         auto fizz = std::make_shared<Fizz>(foo, bar);
 
@@ -151,11 +150,11 @@ Dynamic bindings can be used to resolve factory functions.
 
 ```cpp
 
-container.bind<std::function<IFizzPtr()>>(symbols::fizzFactory).toDynamicValue(
+container.bind(symbols::fizzFactory).toDynamicValue(
     [](const inversify::Context& ctx) {
         return [&]() {
-            auto foo = ctx.container.get<int>(symbols::foo);
-            auto bar = ctx.container.get<double>(symbols::bar);
+            auto foo = ctx.container.get(symbols::foo);
+            auto bar = ctx.container.get(symbols::bar);
 
             auto fizz = std::make_shared<Fizz>(foo, bar);
 
@@ -174,33 +173,29 @@ Automatic bindings can generate instances, unique_ptr's, and shared_ptr's of a c
 
 ```cpp
 
-container.bind<Fizz>(symbols::autoFizz).to<Fizz>();
-container.bind<IFizzUniquePtr>(symbols::autoFizzUnique).to<Fizz>();
-container.bind<IFizzSharedPtr>(symbols::autoFizzShared).to<Fizz>().inSingletonScope();
+container.bind(symbols::autoFizzUnique).to<Fizz>();
+container.bind(symbols::autoFizzShared).to<Fizz>().inSingletonScope();
 
 ```
 
 #### Resolving Dependencies
 
 ```cpp
 
-auto bar = container.get<double>(symbols::bar);
+auto bar = container.get(symbols::bar);
 
-auto fizz = container.get<IFizzPtr>(symbols::fizz);
+auto fizz = container.get(symbols::fizz);
 fizz->buzz();
 
-auto fizzFactory = container.get<std::function<IFizzPtr()>>(symbols::fizzFactory);
+auto fizzFactory = container.get(symbols::fizzFactory);
 auto anotherFizz = fizzFactory();
 anotherFizz->buzz();
 
 
-auto autoFizz = container.get<Fizz>(symbols::autoFizz);
-autoFizz.buzz();
-
-auto autoFizzUnique = container.get<IFizzUniquePtr>(symbols::autoFizzUnique);
+auto autoFizzUnique = container.get(symbols::autoFizzUnique);
 autoFizzUnique->buzz();
 
-auto autoFizzShared = container.get<IFizzSharedPtr>(symbols::autoFizzShared);
+auto autoFizzShared = container.get(symbols::autoFizzShared);
 autoFizzShared->buzz();
 
 ```

diff --git a/example/api/symbols.hpp b/example/api/symbols.hpp
@@ -2,10 +2,14 @@
 
 #include <mosure/inversify.hpp>
 
+#include <api/logger.hpp>
+#include <api/service.hpp>
+#include <api/settings.hpp>
+
 
 namespace inversify = mosure::inversify;
 namespace symbols {
-    inline const inversify::Symbol logger { "Logger" };
-    inline const inversify::Symbol service { "Service" };
-    inline const inversify::Symbol settings { "Settings" };
+    inline extern inversify::Symbol<ILoggerPtr> logger {};
+    inline extern inversify::Symbol<IServicePtr> service {};
+    inline extern inversify::Symbol<ISettings> settings {};
 }
diff --git a/example/src/logger.hpp b/example/src/logger.hpp
@@ -54,6 +54,4 @@ class Logger : public ILogger {
 };
 
 namespace inversify = mosure::inversify;
-inline static auto injectLogger = inversify::Injectable<Logger>::inject(
-    inversify::Inject<ISettings>(symbols::settings)
-);
+inline static auto injectLogger = inversify::Injectable<Logger>::inject(symbols::settings);
diff --git a/example/src/main.cpp b/example/src/main.cpp
@@ -11,15 +11,15 @@
 namespace inversify = mosure::inversify;
 
 int main() {
-    inversify::Container container {};
+    inversify::Container container;
 
-    container.bind<ILoggerPtr>(symbols::logger).to<Logger>().inSingletonScope();
-    container.bind<IServicePtr>(symbols::service).to<Service>();
-    container.bind<ISettings>(symbols::settings).to<Settings>().inSingletonScope();
+    container.bind(symbols::logger).to<Logger>().inSingletonScope();
+    container.bind(symbols::service).to<Service>();
+    container.bind(symbols::settings).to<Settings>().inSingletonScope();
 
     //container.bind<ILoggerPtr>(symbols::logger).to<MockLogger>().inSingletonScope();
 
-    container.get<IServicePtr>(symbols::service)->run();
+    container.get(symbols::service)->run();
 
     return 0;
 }
diff --git a/example/src/service.hpp b/example/src/service.hpp
@@ -25,6 +25,4 @@ class Service : public IService {
 };
 
 namespace inversify = mosure::inversify;
-inline static auto injectService = inversify::Injectable<Service>::inject(
-    inversify::Inject<ILoggerPtr>(symbols::logger)
-);
+inline static auto injectService = inversify::Injectable<Service>::inject(symbols::logger);
diff --git a/include/mosure/binding.hpp b/include/mosure/binding.hpp
@@ -46,21 +46,21 @@ namespace mosure::inversify {
     template <typename T>
     class Binding : public BindingTo<T> {
         public:
-            explicit Binding(const inversify::Symbol& symbol)
+            explicit Binding(const inversify::Symbol<T>& symbol)
                 :
                 symbol_(symbol)
             { }
 
             T resolve(const Context& context) const {
                 if (!this->resolver_) {
-                    throw inversify::exceptions::ResolutionException("inversify::Resolver not found. Malformed binding: " + symbol_);
+                    throw inversify::exceptions::ResolutionException("inversify::Resolver not found. Malformed binding.");
                 }
 
                 return this->resolver_->resolve(context);
             }
 
         private:
-            const inversify::Symbol& symbol_;
+            const inversify::Symbol<T>& symbol_;
     };
 
 }
diff --git a/include/mosure/container.hpp b/include/mosure/container.hpp
@@ -16,36 +16,36 @@ namespace mosure::inversify {
     class Container : public inversify::IContainer<Container> {
         public:
             template <typename T>
-            inversify::BindingTo<T>& bind(const inversify::Symbol& type) {
+            inversify::BindingTo<T>& bind(const inversify::Symbol<T>& type) {
                 static_assert(!std::is_abstract<T>(), "inversify::Container cannot bind/get abstract class value (use a smart pointer instead).");
 
-                auto binding = inversify::Binding<T>(type);
+                auto binding = inversify::Binding(type);
 
-                auto lookup = bindings_.find(type);
+                auto lookup = bindings_.find(type.id);
                 if (lookup != bindings_.end()) {
-                    bindings_.erase(type);
+                    bindings_.erase(type.id);
                 }
 
-                auto pair = std::make_pair(type, std::any(binding));
+                auto pair = std::make_pair(type.id, std::any(binding));
                 bindings_.insert(pair);
 
-                return std::any_cast<inversify::Binding<T>&>(bindings_.at(type));
+                return std::any_cast<inversify::Binding<T>&>(bindings_.at(type.id));
             }
 
             template <typename T>
-            T get(const inversify::Symbol& type) const {
-                auto symbolBinding = bindings_.find(type);
+            T get(const inversify::Symbol<T>& type) const {
+                auto symbolBinding = bindings_.find(type.id);
                 if (symbolBinding == bindings_.end()) {
-                    throw inversify::exceptions::SymbolException(type);
+                    throw inversify::exceptions::SymbolException();
                 }
 
-                auto binding = std::any_cast<Binding<T>>(symbolBinding->second);
+                auto binding = std::any_cast<inversify::Binding<T>>(symbolBinding->second);
 
                 return binding.resolve(context_);
             }
 
         private:
-            std::unordered_map<inversify::Symbol, std::any> bindings_ { };
+            std::unordered_map<int, std::any> bindings_ { };
             inversify::Context context_ { *this };
     };
 

diff --git a/include/mosure/exceptions/symbol.hpp b/include/mosure/exceptions/symbol.hpp
@@ -2,13 +2,11 @@
 
 #include <stdexcept>
 
-#include <mosure/symbol.hpp>
-
 
 namespace mosure::inversify::exceptions {
 
     struct SymbolException : public std::runtime_error {
-        explicit SymbolException(const inversify::Symbol& symbol) : std::runtime_error("inversify::Symbol not found: " + symbol) { }
+        explicit SymbolException() : std::runtime_error("inversify::Symbol not found.") { }
     };
 
 }
diff --git a/include/mosure/injectable.hpp b/include/mosure/injectable.hpp
@@ -12,22 +12,9 @@
 
 namespace mosure::inversify {
 
-    struct InjectBase {
-        explicit InjectBase(const inversify::Symbol& symbol) : symbol(symbol) {  }
-
-        inversify::Symbol symbol;
-    };
-
-    template <typename Interface>
-    struct Inject : InjectBase {
-        explicit Inject(inversify::Symbol symbol) : InjectBase(symbol) {  }
-
-        using value = Interface;
-    };
-
     template <typename ...Types>
     inline constexpr bool valid_inject_types_v = std::conjunction_v<
-        is_specialization<Types, Inject>...
+        meta::is_specialization<Types, Symbol>...
     >;
 
     template <typename Implementation>
@@ -39,7 +26,7 @@ namespace mosure::inversify {
 
             template <typename... Dependencies>
             inline static Injectable inject(Dependencies... dependencies) {
-                static_assert(valid_inject_types_v<Dependencies...>, "inversify::Injectable dependencies must be of type inversify::Inject");
+                static_assert(valid_inject_types_v<Dependencies...>, "inversify::Injectable dependencies must be of type inversify::Symbol");
 
                 factory = [
                     deps = std::make_tuple(dependencies...)
@@ -79,10 +66,10 @@ namespace mosure::inversify {
         private:
             template <typename Dependency>
             inline static typename Dependency::value resolve_dependency(const inversify::Context& context, Dependency dep) {
-                auto symbol = static_cast<InjectBase>(dep).symbol;
-
                 using Interface = typename Dependency::value;
-                return context.container.template get<Interface>(symbol);
+                auto symbol = static_cast<Symbol<Interface>>(dep);
+
+                return context.container.get(symbol);
             }
     };
 

diff --git a/include/mosure/interfaces/icontainer.hpp b/include/mosure/interfaces/icontainer.hpp
@@ -14,17 +14,17 @@ namespace mosure::inversify {
     class IContainer {
         public:
             template <typename T>
-            inversify::BindingTo<T>& bind(const inversify::Symbol& type) {
+            inversify::BindingTo<T>& bind(const inversify::Symbol<T>& type) {
                 auto crtpImplementation = static_cast<Implementation const *>(this);
 
-                return crtpImplementation->template bind<T>(type);
+                return crtpImplementation->bind(type);
             }
 
             template <typename T>
-            T get(const inversify::Symbol& type) const {
+            T get(const inversify::Symbol<T>& type) const {
                 auto crtpImplementation = static_cast<Implementation const *>(this);
 
-                return crtpImplementation->template get<T>(type);
+                return crtpImplementation->get(type);
             }
     };
 

diff --git a/include/mosure/meta.hpp b/include/mosure/meta.hpp
@@ -1,9 +1,10 @@
 #pragma once
 
 #include <type_traits>
+#include <utility>
 
 
-namespace mosure::inversify {
+namespace mosure::inversify::meta {
 
     template <class T, template <class...> class Template>
     struct is_specialization : std::false_type { };

diff --git a/include/mosure/resolver.hpp b/include/mosure/resolver.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <atomic>
 #include <memory>
 #include <type_traits>
 
@@ -101,7 +102,6 @@ namespace mosure::inversify {
             explicit CachedResolver(ResolverPtr<T> parent) : parent_(parent) { }
 
             T resolve(const inversify::Context& context) override {
-                // TODO: add lock for multi-thread support
                 if (!hasCached_) {
                     hasCached_ = true;
                     cached_ = parent_->resolve(context);
@@ -112,7 +112,7 @@ namespace mosure::inversify {
 
         private:
             T cached_;
-            bool hasCached_ { false };
+            std::atomic<bool> hasCached_ { false };
             ResolverPtr<T> parent_;
     };
 

diff --git a/include/mosure/symbol.hpp b/include/mosure/symbol.hpp
@@ -1,10 +1,20 @@
 #pragma once
 
-#include <string>
+#include <iostream>
 
 
 namespace mosure::inversify {
 
-    using Symbol = std::string;
+    namespace {
+        inline static int counter = 0;
+    }
+
+    template <typename Interface>
+    struct Symbol {
+        Symbol() : id(counter++) { }
+
+        const int id;
+        using value = Interface;
+    };
 
 }