container.hpp

Go to the documentation of this file.

#pragma once
 
#include "aria/abi/export.hpp"
#include <any>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <typeindex>
 
namespace aria::runtime {

class ARIA_RUNTIME_API Container {
public:
    Container();
    ~Container();
 
    Container(const Container&) = delete;
    Container& operator=(const Container&) = delete;
    Container(Container&&) = delete;
    Container& operator=(Container&&) = delete;
 
    template<typename Interface, typename Impl>
    void register_singleton() {
        std::shared_ptr<Interface> ptr = std::make_shared<Impl>();
        register_instance_<Interface>(std::move(ptr));
    }
 
    template<typename Interface>
    void register_instance(std::shared_ptr<Interface> ptr) {
        register_instance_<Interface>(std::move(ptr));
    }
 
    template<typename Interface, typename Impl>
    void register_transient() {
        std::function<std::shared_ptr<Interface>()> typed =
            []() -> std::shared_ptr<Interface> { return std::make_shared<Impl>(); };
        do_register_(typeid(Interface), std::any(std::move(typed)), true);
    }
 
    template<typename Interface>
    void register_factory(std::function<std::shared_ptr<Interface>()> fn) {
        do_register_(typeid(Interface), std::any(std::move(fn)), true);
    }
 
    template<typename Interface>
    [[nodiscard]] std::shared_ptr<Interface> resolve() {
        auto found = do_find_(typeid(Interface));
        if (found) {
            if (found->factory) {
                const auto& fn = std::any_cast<
                    const std::function<std::shared_ptr<Interface>()>&>(found->payload);
                return fn();
            }
            return std::any_cast<const std::shared_ptr<Interface>&>(found->payload);
        }
        throw std::runtime_error(std::string("Container: not registered: ")
                                 + typeid(Interface).name());
    }
 
    template<typename Interface>
    [[nodiscard]] bool has() const {
        return do_has_(typeid(Interface));
    }

    void clear();
 
private:
    template<typename Interface>
    void register_instance_(std::shared_ptr<Interface> ptr) {
        do_register_(typeid(Interface), std::any(std::move(ptr)), false);
    }
 
    struct Registration {
        std::any payload;
        bool factory;
    };
 
    void do_register_(std::type_index ti, std::any payload, bool factory);
    std::shared_ptr<const Registration> do_find_(std::type_index ti) const;
    bool do_has_(std::type_index ti) const;
 
    struct Impl;
    // RAII pImpl; C4251 on the shared_ptr member is a false positive for an
    // incomplete opaque pointee consumed only via non-template API.
#ifdef _MSC_VER
#  pragma warning(push)
#  pragma warning(disable: 4251)
#endif
    std::shared_ptr<Impl> impl_;
#ifdef _MSC_VER
#  pragma warning(pop)
#endif
};
 
}  // namespace aria::runtime