Instances.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_STORAGE_INSTANCES_HPP_
#define ECSTASY_STORAGE_INSTANCES_HPP_
 
#include <concepts>
#include <memory>
#include <stdexcept>
#include <typeindex>
#include <unordered_map>
 
namespace ecstasy
{
    template <typename Base>
    class Instances {
      public:
        Instances() = default;
 
        ~Instances() = default;
 
        Instances(const Instances &other) = delete;
 
        template <std::derived_from<Base> Derived, typename... Args>
        Derived &emplace(Args &&...args)
        {
            std::type_index id(typeid(Derived));
 
            if (_instances.contains(id)) [[unlikely]]
                throw std::logic_error("Duplicate instance");
 
            return *dynamic_cast<Derived *>(
                _instances.emplace(std::make_pair(id, std::make_unique<Derived, Args...>(std::forward<Args>(args)...)))
                    .first->second.get());
        }
 
        [[nodiscard]] const Base &get(const std::type_index &type) const
        {
            return *getPtr(type);
        }
 
        template <std::derived_from<Base> Derived>
        [[nodiscard]] const Derived &get() const
        {
            return *getPtr<Derived>();
        }
 
        [[nodiscard]] Base &get(const std::type_index &type)
        {
            return *getPtr(type);
        }
 
        template <std::derived_from<Base> Derived>
        [[nodiscard]] Derived &get()
        {
            return *getPtr<Derived>();
        }
 
        [[nodiscard]] Base *getPtr(const std::type_index &type) const
        {
            const auto &valueIt = _instances.find(type);
 
            if (valueIt == _instances.end()) [[unlikely]]
                throw std::logic_error("Instance not found");
            return valueIt->second.get();
        }
 
        template <std::derived_from<Base> Derived>
        [[nodiscard]] Derived *getPtr() const
        {
            return dynamic_cast<Derived *>(getPtr(std::type_index(typeid(Derived))));
        }
 
        [[nodiscard]] bool contains(const std::type_index &type) const
        {
            return _instances.contains(type);
        }
 
        template <std::derived_from<Base> Derived>
        [[nodiscard]] bool contains() const
        {
            return contains(std::type_index(typeid(Derived)));
        }
 
        void clear()
        {
            _instances.clear();
        }
 
        [[nodiscard]] constexpr const std::unordered_map<std::type_index, std::unique_ptr<Base>> &
        getInner() const noexcept
        {
            return _instances;
        }
 
      private:
        std::unordered_map<std::type_index, std::unique_ptr<Base>> _instances;
    };
} // namespace ecstasy
 
#endif /* !ECSTASY_STORAGE_INSTANCES_HPP_ */