Injector.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_APPLICATION__INJECTOR
#define COM_BORA_SOFTWARE__BALAU_APPLICATION__INJECTOR

#include <Balau/Application/ApplicationConfiguration.hpp>
#include <Balau/Application/EnvironmentConfiguration.hpp>
#include <Balau/Util/Memory.hpp>

#pragma clang diagnostic push
#pragma ide diagnostic ignored "OCUnusedGlobalDeclarationInspection"

namespace Balau {

class Injector final : public std::enable_shared_from_this<Injector> {

    public: template <typename ... Conf> static std::shared_ptr<Injector> create(const Conf & ... conf) {
        return createInjector(std::shared_ptr<Injector>(), conf ...);
    }

    public: static std::shared_ptr<Injector> create(const std::vector<std::shared_ptr<InjectorConfiguration>> & conf) {
        return createInjector(std::shared_ptr<Injector>(), conf);
    }

    public: void registerPostConstructionCall(const std::function<void (const Injector &)> & call) const {
        registerPostConstructionCallImpl(call);
    }

    public: void registerPreDestructionCall(const std::function<void ()> & call) const {
        registerPreDestructionCallImpl(call);
    }

    public: template <typename T> void registerStaticSingleton(std::shared_ptr<T> * ptrPtr, std::string_view name = std::string_view()) const {
        registerPostConstructionCallImpl([ptrPtr, name] (const Injector & injector) { *ptrPtr  = injector.getShared<T>(name); });
        registerPreDestructionCallImpl([ptrPtr] () { ptrPtr->reset(); });
    }


    public: template <typename ... Conf> std::shared_ptr<Injector> createChild(const Conf & ... conf) const {
        return createInjector(shared_from_this(), conf ...);
    }

    public: std::shared_ptr<Injector> createChild(const std::vector<std::shared_ptr<InjectorConfiguration>> & conf) const {
        return createInjector(shared_from_this(), conf);
    }

    public: std::shared_ptr<Injector> createChild(const std::shared_ptr<Injector> & prototype) const {
        return std::shared_ptr<Injector>(new Injector(PrototypeConstruction(), shared_from_this(), prototype));
    }


    public: class ValidationParent {
        private: std::shared_ptr<const Injector> parent;

        private: explicit ValidationParent(std::shared_ptr<const Injector> parent_)
            : parent(std::move(parent_)) {}

        friend class Injector;
    };

    public: template <typename ... Conf>
    static ValidationParent validate(const Conf & ... conf) {
        return performValidation(std::shared_ptr<Injector>(), conf ...);
    }

    public: static ValidationParent validate(const std::vector<std::shared_ptr<InjectorConfiguration>> & conf) {
        return performValidation(std::shared_ptr<Injector>(), conf);
    }

    public: template <typename ... Conf>
    static ValidationParent validateChild(ValidationParent parent, const Conf & ... conf) {
        return performValidation(parent.parent, conf ...);
    }

    public: static ValidationParent validateChild(const ValidationParent & parent,
                                                  const std::vector<std::shared_ptr<InjectorConfiguration>> & conf) {
        return performValidation(parent.parent, conf);
    }

    public: template <typename InstT>
    bool hasBinding(std::string_view name = std::string_view()) const {
        return GetInstance<InstT>(this).hasBinding(name);
    }

    public: template <typename InstT>
    static Impl::BindingKey createBindingKey(const std::string & name = "") {
        return GetInstance<InstT>::createBindingKey(name);
    }

    public: std::string printBindings(bool printAncestor = false) const {
        return performPrintBindings(printAncestor);
    }

    public: std::string printBindingsDetailed() const {
        return performPrintBindingsDetailed();
    }


    public: template <typename InstT>
    InstT getInstance(std::string_view name = std::string_view()) const {
        return GetInstance<InstT>(this).get(name);
    }


    public: template <typename ValueT>
    ValueT getValue(std::string_view name = std::string_view()) const {
        return GetInstance<ValueT>(this).get(name);
    }

    public: template <typename ValueT>
    ValueT getValue(const ValueT & defaultValue) const {
        return GetInstance<ValueT>(this).get(std::string_view(), defaultValue);
    }

    public: template <typename ValueT>
    ValueT getValue(std::string_view name, const ValueT & defaultValue) const {
        return GetInstance<ValueT>(this).get(name, defaultValue);
    }

    public: template <typename ValueT>
    ValueT getValue(const std::function<ValueT ()> & defaultValueSupplier) const {
        return GetInstance<ValueT>(this).get(std::string_view(), defaultValueSupplier);
    }

    public: template <typename ValueT>
    ValueT getValue(std::string_view name, const std::function<ValueT ()> & defaultValueSupplier) const {
        return GetInstance<ValueT>(this).get(name, defaultValueSupplier);
    }


    public: template <typename BaseT, typename DeleterT = std::default_delete<BaseT>>
    std::unique_ptr<BaseT, DeleterT> getUnique(std::string_view name = std::string_view()) const {
        return GetInstance<std::unique_ptr<BaseT, DeleterT>>(this).get(name);
    }

    public: template <typename BaseT, typename DeleterT = std::default_delete<BaseT>>
    std::unique_ptr<BaseT, DeleterT> getUnique(std::unique_ptr<BaseT> && defaultValue) const {
        return GetInstance<std::unique_ptr<BaseT, DeleterT>>(this).get("", std::move(defaultValue));
    }

    public: template <typename BaseT, typename DeleterT = std::default_delete<BaseT>>
    std::unique_ptr<BaseT, DeleterT> getUnique(std::string_view name, std::unique_ptr<BaseT, DeleterT> && defaultValue) const {
        return GetInstance<std::unique_ptr<BaseT, DeleterT>>(this).get(name, std::move(defaultValue));
    }

    public: template <typename BaseT, typename DeleterT = std::default_delete<BaseT>>
    std::unique_ptr<BaseT, DeleterT> getUnique(std::function<std::unique_ptr<BaseT, DeleterT> ()> & defaultValueSupplier) const {
        return GetInstance<std::unique_ptr<BaseT, DeleterT>>(this).get("", defaultValueSupplier);
    }

    public: template <typename BaseT, typename DeleterT = std::default_delete<BaseT>>
    std::unique_ptr<BaseT, DeleterT> getUnique(std::string_view name, std::function<std::unique_ptr<BaseT, DeleterT> ()> & defaultValueSupplier) const {
        return GetInstance<std::unique_ptr<BaseT, DeleterT>>(this).get(name, defaultValueSupplier);
    }

    public: template <typename BaseT, typename DeleterT = std::default_delete<BaseT>>
    std::unique_ptr<BaseT, DeleterT> getUniqueOrNull(std::string_view name = std::string_view()) const {
        return GetInstance<std::unique_ptr<BaseT, DeleterT>>(this).get(name, std::unique_ptr<BaseT, DeleterT>());
    }


    public: template <typename BaseT> BaseT & getReference(std::string_view name = std::string_view()) const {
        return GetInstance<BaseT &>(this).get(name);
    }

    public: template <typename BaseT> BaseT & getReference(BaseT & defaultValue) const {
        return GetInstance<BaseT &>(this).get(std::string_view(), defaultValue);
    }

    public: template <typename BaseT> BaseT & getReference(std::string_view name, BaseT & defaultValue) const {
        return GetInstance<BaseT &>(this).get(name, defaultValue);
    }


    public: template <typename BaseT> std::shared_ptr<BaseT> getShared(std::string_view name = std::string_view()) const {
        return GetInstance<std::shared_ptr<BaseT>>(this).get(name);
    }

    public: template <typename BaseT>
    std::shared_ptr<BaseT> getShared(const std::shared_ptr<BaseT> & defaultValue) const {
        return GetInstance<std::shared_ptr<BaseT>>(this).get(std::string_view(), defaultValue);
    }

    public: template <typename BaseT>
    std::shared_ptr<BaseT> getShared(std::string_view name, const std::shared_ptr<BaseT> & defaultValue) const {
        return GetInstance<std::shared_ptr<BaseT>>(this).get(name, defaultValue);
    }

    public: template <typename BaseT>
    std::shared_ptr<BaseT> getShared(const std::function<std::shared_ptr<BaseT> ()> & defaultValueSupplier) const {
        return GetInstance<std::shared_ptr<BaseT>>(this).get(std::string_view(), defaultValueSupplier);
    }

    public: template <typename BaseT>
    std::shared_ptr<BaseT> getShared(std::string_view name, const std::function<std::shared_ptr<BaseT> ()> & defaultValueSupplier) const {
        return GetInstance<std::shared_ptr<BaseT>>(this).get(name, defaultValueSupplier);
    }

    public: template <typename BaseT>
    std::shared_ptr<BaseT> getSharedOrNull(std::string_view name = std::string_view()) const {
        return GetInstance<std::shared_ptr<BaseT>>(this).get(name, std::shared_ptr<BaseT>());
    }


    public: template <typename BaseT>
    void iterate(const std::function<void (std::shared_ptr<BaseT>)> & func, bool includeThreadLocal = false) const {
        iterateOverShared<BaseT>(func, includeThreadLocal);
    }

    public: template <typename BaseT>
    void iterate(const std::function<void (std::shared_ptr<const BaseT>)> & func, bool includeThreadLocal = false) const {
        iterateOverShared<BaseT>(func, includeThreadLocal);
    }


    //
    // Non-specialised GetInstance template class.
    // This GetInstance template class deals with the non-const value meta-type.
    //
    private: template <typename T> struct GetInstance {
        T get(std::string_view name) const {
            return injector->getValueImpl<T>(name);
        }

        T get(std::string_view name, const T & defaultValue) const {
            return injector->getValueImpl<T>(name, defaultValue);
        }

        T get(std::string_view name, const std::function<T ()> & defaultValueSupplier) const {
            return injector->getValueImpl<T>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, T>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, T>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for const T.
    // This immediately promotes to T.
    //
    private: template <typename T> struct GetInstance<const T> {
        using U = typename std::remove_const<T>::type;

        U get(std::string_view name) const {
            return injector->getValueImpl<U>(name);
        }

        U get(std::string_view name, const T & defaultValue) const {
            return injector->getValueImpl<U>(name, defaultValue);
        }

        U get(std::string_view name, const std::function<T ()> & defaultValueSupplier) const {
            return injector->getValueImpl<U>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, T>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, T>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for std::unique_ptr<T>.
    //
    private: template <typename BaseT, typename DeleterT> struct GetInstance<std::unique_ptr<BaseT, DeleterT>> {
        std::unique_ptr<BaseT, DeleterT> get(std::string_view name) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name);
        }

        std::unique_ptr<BaseT, DeleterT> get(std::string_view name, std::unique_ptr<BaseT, DeleterT> & defaultValue) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name, defaultValue);
        }

        std::unique_ptr<BaseT, DeleterT> get(std::string_view name, const std::function<std::unique_ptr<BaseT, DeleterT> ()> & defaultValueSupplier) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for const std::unique_ptr<T>.
    // This immediately promotes to std::unique_ptr<T>.
    //
    private: template <typename BaseT, typename DeleterT> struct GetInstance<const std::unique_ptr<BaseT, DeleterT>> {
        std::unique_ptr<BaseT, DeleterT> get(std::string_view name) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name);
        }

        std::unique_ptr<BaseT, DeleterT> get(std::string_view name, std::unique_ptr<BaseT, DeleterT> & defaultValue) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name, defaultValue);
        }

        std::unique_ptr<BaseT, DeleterT> get(std::string_view name, const std::function<std::unique_ptr<BaseT, DeleterT> ()> & defaultValueSupplier) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for std::unique_ptr<const T>.
    // This immediately promotes to std::unique_ptr<T>.
    //
    private: template <typename BaseT, typename DeleterT> struct GetInstance<std::unique_ptr<const BaseT, DeleterT>> {
        std::unique_ptr<BaseT, DeleterT> get(std::string_view name) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name);
        }

        std::unique_ptr<BaseT, DeleterT> get(std::string_view name, std::unique_ptr<BaseT, DeleterT> & defaultValue) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name, defaultValue);
        }

        std::unique_ptr<BaseT, DeleterT> get(std::string_view name, const std::function<std::unique_ptr<BaseT, DeleterT> ()> & defaultValueSupplier) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for const std::unique_ptr<const T>.
    // This immediately promotes to std::unique_ptr<T>.
    //
    private: template <typename BaseT, typename DeleterT> struct GetInstance<const std::unique_ptr<const BaseT, DeleterT>> {
        std::unique_ptr<BaseT, DeleterT> get(std::string_view name) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name);
        }

        std::unique_ptr<BaseT, DeleterT> get(std::string_view name, std::unique_ptr<BaseT, DeleterT> & defaultValue) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name, defaultValue);
        }

        std::unique_ptr<BaseT, DeleterT> get(std::string_view name, const std::function<std::unique_ptr<BaseT, DeleterT> ()> & defaultValueSupplier) const {
            return injector->getUniqueImpl<BaseT, DeleterT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for T &.
    //
    private: template <typename T> struct GetInstance<T &> {
        T & get(std::string_view name) const {
            return injector->getReferenceImpl<T>(name);
        }

        T & get(std::string_view name, T & defaultValue) const {
            return injector->getReferenceImpl<T>(name, defaultValue);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Reference, T>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Reference, T>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for const T &.
    // This will use a suitable non-const T & binding if no const T & binding is not available.
    //
    private: template <typename T> struct GetInstance<const T &> {
        const T & get(std::string_view name) const {
            return injector->getReferenceImpl<const T>(name);
        }

        const T & get(std::string_view name, const T & defaultValue) const {
            return injector->getReferenceImpl<const T>(name, defaultValue);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Reference, const T>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Reference, const T>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for std::shared_ptr<BaseT>.
    //
    private: template <typename BaseT> struct GetInstance<std::shared_ptr<BaseT>> {
        std::shared_ptr<BaseT> get(std::string_view name) const {
            return injector->getSharedImpl<BaseT>(name);
        }

        std::shared_ptr<BaseT> get(std::string_view name, const std::shared_ptr<BaseT> & defaultValue) const {
            return injector->getSharedImpl<BaseT>(name, defaultValue);
        }

        std::shared_ptr<BaseT> get(std::string_view name, const std::function<std::shared_ptr<BaseT> ()> & defaultValueSupplier) const {
            return injector->getSharedImpl<BaseT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for const std::shared_ptr<BaseT>.
    // This immediately promotes to std::shared_ptr<T>.
    //
    private: template <typename BaseT> struct GetInstance<const std::shared_ptr<BaseT>> {
        std::shared_ptr<BaseT> get(std::string_view name) const {
            return injector->getSharedImpl<BaseT>(name);
        }

        std::shared_ptr<BaseT> get(std::string_view name, const std::shared_ptr<BaseT> & defaultValue) const {
            return injector->getSharedImpl<BaseT>(name, defaultValue);
        }

        std::shared_ptr<BaseT> get(std::string_view name, const std::function<std::shared_ptr<BaseT> ()> & defaultValueSupplier) const {
            return injector->getSharedImpl<BaseT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for std::shared_ptr<const T>.
    // This will use a suitable non-const std::shared_ptr<const T> binding
    // if no const std::shared_ptr<const T> binding is available.
    //
    private: template <typename BaseT> struct GetInstance<std::shared_ptr<const BaseT>> {
        std::shared_ptr<const BaseT> get(std::string_view name) const {
            return injector->getSharedImpl<const BaseT>(name);
        }

        std::shared_ptr<const BaseT> get(std::string_view name, std::shared_ptr<const BaseT> & defaultValue) const {
            return injector->getSharedImpl<const BaseT>(name, defaultValue);
        }

        std::shared_ptr<const BaseT> get(std::string_view name, const std::function<std::shared_ptr<const BaseT> ()> & defaultValueSupplier) const {
            return injector->getSharedImpl<const BaseT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, const BaseT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, const BaseT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for const std::shared_ptr<const T>.
    // This immediately promotes to std::shared_ptr<const T>.
    //
    private: template <typename BaseT> struct GetInstance<const std::shared_ptr<const BaseT>> {
        std::shared_ptr<const BaseT> get(std::string_view name) const {
            return injector->getSharedImpl<const BaseT>(name);
        }

        std::shared_ptr<const BaseT> get(std::string_view name, std::shared_ptr<const BaseT> & defaultValue) const {
            return injector->getSharedImpl<const BaseT>(name, defaultValue);
        }

        std::shared_ptr<const BaseT> get(std::string_view name, const std::function<std::shared_ptr<const BaseT> ()> & defaultValueSupplier) const {
            return injector->getSharedImpl<const BaseT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, const BaseT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, const BaseT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for std::weak_ptr<T>.
    // This immediately promotes to std::shared_ptr<T>.
    //
    private: template <typename BaseT> struct GetInstance<std::weak_ptr<BaseT>> {
        std::shared_ptr<BaseT> get(std::string_view name) const {
            return injector->getSharedImpl<BaseT>(name);
        }

        std::shared_ptr<BaseT> get(std::string_view name, std::shared_ptr<BaseT> & defaultValue) const {
            return injector->getSharedImpl<BaseT>(name, defaultValue);
        }

        std::shared_ptr<BaseT> get(std::string_view name, const std::function<std::shared_ptr<BaseT> ()> & defaultValueSupplier) const {
            return injector->getSharedImpl<BaseT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for const std::weak_ptr<T>.
    // This immediately promotes to std::shared_ptr<T>.
    //
    private: template <typename BaseT> struct GetInstance<const std::weak_ptr<BaseT>> {
        std::shared_ptr<BaseT> get(std::string_view name) const {
            return injector->getSharedImpl<BaseT>(name);
        }

        std::shared_ptr<BaseT> get(std::string_view name, std::shared_ptr<BaseT> & defaultValue) const {
            return injector->getSharedImpl<BaseT>(name, defaultValue);
        }

        std::shared_ptr<BaseT> get(std::string_view name, const std::function<std::shared_ptr<BaseT> ()> & defaultValueSupplier) const {
            return injector->getSharedImpl<BaseT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for std::weak_ptr<const T>.
    // This immediately promotes to std::shared_ptr<const T>.
    //
    private: template <typename BaseT> struct GetInstance<std::weak_ptr<const BaseT>> {
        std::shared_ptr<const BaseT> get(std::string_view name) const {
            return injector->getSharedImpl<const BaseT>(name);
        }

        std::shared_ptr<const BaseT> get(std::string_view name, std::shared_ptr<const BaseT> & defaultValue) const {
            return injector->getSharedImpl<const BaseT>(name, defaultValue);
        }

        std::shared_ptr<const BaseT> get(std::string_view name, const std::function<std::shared_ptr<const BaseT> ()> & defaultValueSupplier) const {
            return injector->getSharedImpl<const BaseT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, const BaseT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, const BaseT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };

    //
    // GetInstance template class specialised for const std::weak_ptr<const T>.
    // This immediately promotes to std::shared_ptr<const T>.
    //
    private: template <typename BaseT> struct GetInstance<const std::weak_ptr<const BaseT>> {
        std::shared_ptr<const BaseT> get(std::string_view name) const {
            return injector->getSharedImpl<const BaseT>(name);
        }

        std::shared_ptr<const BaseT> get(std::string_view name, std::shared_ptr<const BaseT> & defaultValue) const {
            return injector->getSharedImpl<const BaseT>(name, defaultValue);
        }

        std::shared_ptr<const BaseT> get(std::string_view name, const std::function<std::shared_ptr<const BaseT> ()> & defaultValueSupplier) const {
            return injector->getSharedImpl<const BaseT>(name, defaultValueSupplier);
        }

        bool hasBinding(std::string_view name) const {
            return injector->hasBinding(createBindingKeyView(name));
        }

        static Impl::BindingKey createBindingKey(std::string name) {
            return Impl::BindingKey(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, const BaseT>), std::move(name));
        }

        static Impl::BindingKeyView createBindingKeyView(std::string_view name) {
            return Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, const BaseT>), name);
        }

        explicit GetInstance(const Injector * injector_) : injector(injector_) {}
        const Injector * injector;
    };


    private: template <typename T> T getValueImpl(std::string_view name) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, T>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return createValueInstance<T>(*binding);
        } else if (parent) {
            return parent->getValueImpl<T>(name);
        } else {
            ThrowBalauException(Exception::NoBindingException, keyView.toKey());
        }
    }

    private: template <typename T> T getValueImpl(std::string_view name, const T & defaultValue) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, T>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return createValueInstance<T>(*binding);
        } else if (parent) {
            return parent->getValueImpl<T>(name, defaultValue);
        } else {
            return defaultValue;
        }
    }

    private: template <typename T> T getValueImpl(std::string_view name, const std::function<T ()> & defaultValueSupplier) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, T>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return createValueInstance<T>(*binding);
        } else if (parent) {
            return parent->getValueImpl<T>(name, defaultValueSupplier);
        } else {
            return defaultValueSupplier();
        }
    }

    private: template <typename T>
    T & getReferenceImpl(std::string_view name) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Reference, T>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return getReferenceInstance<T>(*binding);
        } else if (parent) {
            return parent->getReferenceImpl<T>(name);
        } else {
            // Try a non-const binding?
            if (Impl::BindingKeyType<Impl::BindingMetaType::Reference, T>::isConst) {
                return getReferenceImpl<typename std::remove_const<T>::type>(name);
            } else {
                ThrowBalauException(Exception::NoBindingException, keyView.toKey());
            }
        }
    }

    private: template <typename T>
    T & getReferenceImpl(std::string_view name, T & defaultValue) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Reference, T>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return getReferenceInstance<T>(*binding);
        } else if (parent) {
            return parent->getReferenceImpl<T>(name, defaultValue);
        } else {
            // Try a non-const binding?
            if (Impl::BindingKeyType<Impl::BindingMetaType::Reference, T>::isConst) {
                return getReferenceImpl<typename std::remove_const<T>::type>(name, defaultValue);
            } else {
                return defaultValue;
            }
        }
    }

    private: template <typename BaseT, typename DeleterT>
    std::unique_ptr<BaseT, DeleterT> getUniqueImpl(std::string_view name) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return createUniqueInstance<BaseT, DeleterT>(*binding);
        } else if (parent) {
            return parent->getUniqueImpl<BaseT, DeleterT>(name);
        } else {
            ThrowBalauException(Exception::NoBindingException, keyView.toKey());
        }
    }

    private: template <typename BaseT, typename DeleterT>
    std::unique_ptr<BaseT, DeleterT> getUniqueImpl(std::string_view name, std::unique_ptr<BaseT> && defaultValue) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return createUniqueInstance<BaseT, DeleterT>(*binding);
        } else if (parent) {
            return parent->getUniqueImpl<BaseT, DeleterT>(name, std::move(defaultValue));
        } else {
            return std::move(defaultValue);
        }
    }

    private: template <typename BaseT, typename DeleterT>
    std::unique_ptr<BaseT, DeleterT> getUniqueImpl(std::string_view name, std::function<std::unique_ptr<BaseT> ()> & defaultValueSupplier) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, DeleterT>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return createUniqueInstance<BaseT, DeleterT>(*binding);
        } else if (parent) {
            return parent->getUniqueImpl<BaseT, DeleterT>(name, defaultValueSupplier);
        } else {
            return defaultValueSupplier();
        }
    }

    private: template <typename BaseT>
    std::shared_ptr<BaseT> getSharedImpl(std::string_view name) const {
        const auto typeIndex = std::type_index(typeid(BaseT));
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return getSharedInstance<BaseT>(*binding);
        } else if (typeIndex == std::type_index(typeid(Injector))) {
            // If we are here, then BaseT == Injector and the cast disappears.
            auto ptr = std::const_pointer_cast<Injector>(shared_from_this());
            return std::reinterpret_pointer_cast<BaseT>(ptr);
        } else if (parent) {
            return parent->getSharedImpl<BaseT>(name);
        } else {
            // Try a non-const binding?
            if (Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>::isConst) {
                return getSharedImpl<typename std::remove_const<BaseT>::type>(name);
            } else {
                ThrowBalauException(Exception::NoBindingException, keyView.toKey());
            }
        }
    }

    private: template <typename BaseT>
    std::shared_ptr<BaseT> getSharedImpl(std::string_view name, const std::shared_ptr<BaseT> & defaultValue) const {
        const auto typeIndex = std::type_index(typeid(BaseT));
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return getSharedInstance<BaseT>(*binding);
        } else if (typeIndex == std::type_index(typeid(Injector))) {
            // If we are here, then BaseT == Injector and the cast disappears.
            auto ptr = std::const_pointer_cast<Injector>(shared_from_this());
            return std::reinterpret_pointer_cast<BaseT>(ptr);
        } else if (parent) {
            return parent->getSharedImpl<BaseT>(name, defaultValue);
        } else {
            // Try a non-const binding?
            if (Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>::isConst) {
                return getSharedImpl<typename std::remove_const<BaseT>::type>(name, defaultValue);
            } else {
                return defaultValue;
            }
        }
    }

    private: template <typename BaseT>
    std::shared_ptr<BaseT> getSharedImpl(std::string_view name, const std::function<std::shared_ptr<BaseT> ()> & defaultValueSupplier) const {
        const auto typeIndex = std::type_index(typeid(BaseT));
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>), name);

        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return getSharedInstance<BaseT>(*binding);
        } else if (typeIndex == std::type_index(typeid(Injector))) {
            // If we are here, then BaseT == Injector and the cast disappears.
            auto ptr = std::const_pointer_cast<Injector>(shared_from_this());
            return std::reinterpret_pointer_cast<BaseT>(ptr);
        } else if (parent) {
            return parent->getSharedImpl<BaseT>(name, defaultValueSupplier);
        } else {
            // Try a non-const binding?
            if (Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>::isConst) {
                return getSharedImpl<typename std::remove_const<BaseT>::type>(name, defaultValueSupplier);
            } else {
                return defaultValueSupplier();
            }
        }
    }

    private: template <typename BaseT>
    void iterateOverShared(const std::function<void (std::shared_ptr<BaseT>)> & func, bool includeThreadLocal = false) {
        const auto typeIndex = std::type_index(typeid(BaseT));

        for (const auto & binding : (*bindings)) {
            if (binding.key.getType() == typeIndex) {
                if (includeThreadLocal || !binding.value->isThreadLocalBinding()) {
                    func(getSharedInstance<BaseT>(binding.value));
                }
            }
        }
    }

    private: template <typename BaseT>
    void iterateOverShared(const std::function<void (std::shared_ptr<const BaseT>)> & func, bool includeThreadLocal = false) {
        const auto typeIndex = std::type_index(typeid(BaseT));

        for (const auto & binding : (*bindings)) {
            if (binding.key.getType() == typeIndex) {
                if (includeThreadLocal || !binding.value->isThreadLocalBinding()) {
                    func(getSharedInstance<BaseT>(binding.value));
                }
            }
        }
    }


    // Create a non-polymorphic value from the supplied value, prototype, or value provider
    // binding. The type T has been tunnelled through and matched to the binding.
    private: template <typename T>
    T createValueInstance(const std::unique_ptr<Impl::AbstractBinding> & binding) const {
        return static_cast<const Impl::AbstractValueBinding<T> *>(binding.get())->get(this);
    }

    // Get a reference from the supplied reference binding. The type T has been
    // tunnelled through and matched to the binding.
    private: template <typename T>
    T & getReferenceInstance(const std::unique_ptr<Impl::AbstractBinding> & binding) const {
        return static_cast<const Impl::AbstractReferenceBinding<T> *>(binding.get())->get(this);
    }

    // Create a polymorphic unique ptr from the supplied unique ptr or unique ptr provider
    // binding. The type T has been tunnelled through and matched to the binding.
    private: template <typename T, typename DeleterT = std::default_delete<T>>
    std::unique_ptr<T, DeleterT> createUniqueInstance(const std::unique_ptr<Impl::AbstractBinding> & binding) const {
        return static_cast<const Impl::AbstractUniquePtrBinding<T, DeleterT> *>(binding.get())->get(this);
    }

    // Get a polymorphic shared ptr from the supplied thread-local singleton or singleton binding.
    // The type T has been tunnelled through and matched to the binding.
    private: template <typename T>
    std::shared_ptr<T> getSharedInstance(const std::unique_ptr<Impl::AbstractBinding> & binding) const {
        return static_cast<const Impl::AbstractSharedPtrBinding<T> *>(binding.get())->get(this);
    }


    // Used to determine presence of a binding the injector or its parent.
    private: bool hasBinding(const Impl::BindingKeyView & keyView) const {
        return bindings->hasBinding(keyView) || (parent && parent->hasBinding(keyView));
    }

    public: Injector(const Injector &) = delete;
    public: Injector & operator = (const Injector &) = delete;

    //
    // Environment property text is owned by the injector.
    //
    // This allows the const char pointers of the strings to be used in the
    // binding keys without dangling pointer issues.
    //
    using PropertyTextVectorPtr = std::shared_ptr<std::vector<std::string>>;

    private: template <typename ... Conf>
    static std::shared_ptr<Injector> createInjector(const std::shared_ptr<const Injector> & parent, const Conf & ... conf) {
        auto injector = std::shared_ptr<Injector>(new Injector(parent, conf ...)); // NOLINT
        Impl::BindingGraph graph;
        injector->performValidation(graph);

        // Instantiate eager singletons in the correct order.
        for (auto & key : graph.dependencyOrder()) {
            injector->bindings->get(key)->instantiateIfEager(*injector);
        }

        if (Impl::InjectorLogger::log().enabled(LoggingLevel::TRACE)) {
            Impl::InjectorLogger::log().trace(injector->printBindings(false).c_str());
        }

        for (const auto & f : injector->postConstructionCalls) {
            f(*injector);
        }

        return injector;
    }

    private: static std::shared_ptr<Injector> createInjector(const std::shared_ptr<const Injector> & parent,
                                                             const std::vector<std::shared_ptr<InjectorConfiguration>> & conf) {
        auto injector = std::shared_ptr<Injector>(new Injector(parent, conf)); // NOLINT
        Impl::BindingGraph graph;
        injector->performValidation(graph);

        // Instantiate eager singletons in the correct order.
        for (auto & key : graph.dependencyOrder()) {
            injector->bindings->get(key)->instantiateIfEager(*injector);
        }

        if (Impl::InjectorLogger::log().enabled(LoggingLevel::TRACE)) {
            Impl::InjectorLogger::log().trace(injector->printBindings(false).c_str());
        }

        for (const auto & f : injector->postConstructionCalls) {
            f(*injector);
        }

        return injector;
    }

    // Main constructor.
    private: template <typename ... Conf>
    explicit Injector(std::shared_ptr<const Injector> parent_, const Conf & ... conf)
        : parent(std::move(parent_))
        , bindings(createBindings(conf ...)) {}

    // Main constructor.
    private: Injector(std::shared_ptr<const Injector> parent_, const std::vector<std::shared_ptr<InjectorConfiguration>> & conf)
        : parent(std::move(parent_))
        , bindings(createBindings(conf)) {}

    private: class PrototypeConstruction {};

    // Prototype constructor.
    // Copy the bindings shared ptr instead of moving it.
    private: Injector(PrototypeConstruction,
                      std::shared_ptr<const Injector> parent_,
                      const std::shared_ptr<const Injector> & prototype)
        : parent(std::move(parent_))
        , bindings(prototype->bindings) {}

    public: ~Injector() {
        for (const auto & f : preDestructionCalls) {
            f();
        }
    }

    private: template <typename ... Conf> std::shared_ptr<Impl::BindingMap> createBindings(const Conf & ... conf) {
        std::vector<const InjectorConfiguration *> extraConfiguration;

        auto builders = Util::Memory::makeSharedV<InjectorConfiguration, Impl::BindingBuilderBase>(
            [&extraConfiguration, this] (const InjectorConfiguration & conf) {
                auto b = conf.execute();
                Util::Containers::append(postConstructionCalls, conf.getPostConstructionCalls());
                Util::Containers::append(preDestructionCalls, conf.getPreDestructionCalls());

                auto s = conf.getStaticSingletonPostConstructionCalls();

                auto extra = conf.getExtraConfiguration();
                extraConfiguration.insert(extraConfiguration.end(), extra.begin(), extra.end());
                return b;
            }
            , conf ...
        );

        for (const auto & c : extraConfiguration) {
            Util::Containers::append(builders, c->execute());
            Util::Containers::append(postConstructionCalls, c->getPostConstructionCalls());
            Util::Containers::append(preDestructionCalls, c->getPreDestructionCalls());
        }

        auto theBindings = std::make_shared<Impl::BindingMap>();

        for (auto & builder : builders) {
            Impl::BindingKey key(builder->key);

            // Check for duplicates.
            if (theBindings->hasBinding(key)) {
                ThrowBalauException(Exception::DuplicateBindingException, key);
            }

            theBindings->put(key, builder->build());
        }

        return theBindings;
    }

    private: std::shared_ptr<Impl::BindingMap> createBindings(const std::vector<std::shared_ptr<InjectorConfiguration>> & conf) {
        std::vector<std::shared_ptr<Impl::BindingBuilderBase>> builders;

        for (const auto & c : conf) {
            Util::Containers::append(builders, c->execute());
            Util::Containers::append(postConstructionCalls, c->getPostConstructionCalls());
            Util::Containers::append(preDestructionCalls, c->getPreDestructionCalls());
        }

        for (const auto & c : conf) {
            for (const auto * c2 : c->getExtraConfiguration()) {
                Util::Vectors::append(builders, c2->execute());
                Util::Containers::append(postConstructionCalls, c2->getPostConstructionCalls());
                Util::Containers::append(preDestructionCalls, c2->getPreDestructionCalls());
            }
        }

        auto theBindings = std::make_shared<Impl::BindingMap>();

        for (auto & builder : builders) {
            Impl::BindingKey key(builder->key);

            // Check for duplicates.
            if (theBindings->hasBinding(key)) {
                ThrowBalauException(Exception::DuplicateBindingException, key);
            }

            theBindings->put(key, builder->build());
        }

        return theBindings;
    }

    private: void registerPostConstructionCallImpl(const std::function<void (const Injector &)> & call) const {
        std::lock_guard<std::recursive_mutex> lock(callSync);
        postConstructionCalls.push_back(call);
    }

    private: void registerPreDestructionCallImpl(const std::function<void ()> & call) const {
        std::lock_guard<std::recursive_mutex> lock(callSync);
        preDestructionCalls.push_back(call);
    }

    private: template <typename ... Conf>
    static ValidationParent performValidation(const std::shared_ptr<const Injector> & parent, const Conf & ... conf) {
        auto injector = std::shared_ptr<Injector>(new Injector(parent, conf ...)); // NOLINT
        Impl::BindingGraph graph;
        injector->performValidation(graph);
        return ValidationParent(injector);
    }

    private: static ValidationParent performValidation(const std::shared_ptr<const Injector> & parent,
                                                       const std::vector<std::shared_ptr<InjectorConfiguration>> & conf) {
        auto injector = std::shared_ptr<Injector>(new Injector(std::move(parent), conf)); // NOLINT
        Impl::BindingGraph graph;
        injector->performValidation(graph);
        return ValidationParent(injector);
    }

    private: void performValidation(Impl::BindingGraph & graph) const {
        // Create the vertices of the dependency graph.
        for (const auto & binding : *bindings) {
            const auto & key = binding.key;

            // Check for duplicates.
            if (graph.lookupDependency(key) != nullptr) {
                ThrowBalauException(Exception::DuplicateBindingException, key);
            }

            graph.addDependency(key);
        }

        const auto weak = Impl::BindingMetaType::WeakPromotion;
        const auto shared = Impl::BindingMetaType::Shared;
        const Impl::BindingKey weakKey(typeid(Impl::BindingKeyType<weak, Injector>), "");
        const Impl::BindingKey constWeakKey(typeid(Impl::BindingKeyType<weak, const Injector>), "");
        const Impl::BindingKey sharedKey(typeid(Impl::BindingKeyType<shared, Injector>), "");
        const Impl::BindingKey constSharedKey(typeid(Impl::BindingKeyType<shared, const Injector>), "");

        // Validate and create the edges of the dependency graph.
        for (const auto & binding : (*bindings)) {
            binding.value->registerDependencies(graph, weakKey, constWeakKey, sharedKey, constSharedKey);
        }

        graph.logGraph(LoggingLevel::TRACE, "Injector dependency graph");

        std::vector<std::pair<Impl::BindingKey, Impl::BindingKey>> cycleEdges;

        if (graph.hasCycles(cycleEdges)) {
            ThrowBalauException(Exception::CyclicDependencyException, "Cycle edges found:\n" + printCyclicEdges(cycleEdges));
        }
    }

    private: std::string performPrintBindings(bool printAncestor) const {
        std::ostringstream builder;
        std::string_view prefix;
        performPrintBindings(builder, prefix, printAncestor);
        return builder.str();
    }

    private: void performPrintBindings(std::ostream & builder, std::string_view & prefix, bool pa) const {
        for (const auto & binding : (*bindings)) {
            builder << prefix << Impl::toString(binding.key);
            prefix = "\n";
        }

        if (pa && parent) {
            parent->performPrintBindings(builder, prefix, pa);
        }
    }

    private: std::string performPrintBindingsDetailed() const {
        std::ostringstream builder;
        std::string_view prefix;
        performPrintBindingsDetailed(builder, prefix);
        return builder.str();
    }

    private: void performPrintBindingsDetailed(std::ostream & builder, std::string_view & prefix) const {
        for (const auto & binding : (*bindings)) {
            builder << prefix << Impl::toString(binding.key);
            prefix = "\n";

            for (const auto & dependency : binding.value->getDependencyKeys()) {
                builder << prefix << "    " << Impl::toString(dependency);
            }
        }

        if (parent) {
            parent->performPrintBindingsDetailed(builder, prefix);
        }
    }

    private: static std::string printCyclicEdges(const std::vector<std::pair<Impl::BindingKey, Impl::BindingKey>> & cycleEdges) {
        std::ostringstream builder;
        std::string_view prefix;

        for (const auto & cycleEdge : cycleEdges) {
            builder << prefix << Impl::toString(cycleEdge.first) << " --> " << Impl::toString(cycleEdge.second);
            prefix = "\n";
        }

        return builder.str();
    }

    // Main injector state.
    private: const std::shared_ptr<const Injector> parent;
    private: const std::shared_ptr<const Impl::BindingMap> bindings;

    // Data structures for callbacks.
    private: mutable std::list<std::function<void (const Injector& )>> postConstructionCalls;
    private: mutable std::list<std::function<void ()>> preDestructionCalls;
    private: mutable std::recursive_mutex callSync;
};

} // namespace Balau

#pragma clang diagnostic pop

#endif // COM_BORA_SOFTWARE__BALAU_APPLICATION__INJECTOR