SystemInstances.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_STORAGE_SYSTEM_INSTANCES_HPP_
#define ECSTASY_STORAGE_SYSTEM_INSTANCES_HPP_
 
#include <concepts>
#include <map>
#include <memory>
#include <stdexcept>
#include <typeindex>
 
namespace ecstasy
{
    class ISystem;
 
    class SystemInstances {
      private:
        using key_type = std::pair<std::type_index, size_t>;
 
        class Comparer {
          public:
            using is_transparent = std::true_type;
 
            Comparer() = default;
 
            bool operator()(const key_type &a, const std::type_index &b) const
            {
                return a.first < b;
            }
 
            bool operator()(const std::type_index &a, const key_type &b) const
            {
                return a < b.first;
            }
 
            bool operator()(const key_type &a, const key_type &b) const
            {
                if (a.second == b.second)
                    return a.first < b.first;
                else
                    return a.second < b.second;
            }
        };
 
      public:
        SystemInstances() = default;
 
        ~SystemInstances() = default;
 
        SystemInstances(const SystemInstances &other) = delete;
 
        template <std::derived_from<ISystem> Derived, size_t Priority = 0, 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(std::make_pair(id, Priority),
                                                    std::make_unique<Derived, Args...>(std::forward<Args>(args)...)))
                                                .first->second.get());
        }
 
        [[nodiscard]] const ISystem &get(const std::type_index &type) const
        {
            return *getPtr(type);
        }
 
        template <std::derived_from<ISystem> Derived>
        [[nodiscard]] const Derived &get() const
        {
            return *getPtr<Derived>();
        }
 
        [[nodiscard]] ISystem &get(const std::type_index &type)
        {
            return *getPtr(type);
        }
 
        template <std::derived_from<ISystem> Derived>
        [[nodiscard]] Derived &get()
        {
            return *getPtr<Derived>();
        }
 
        [[nodiscard]] ISystem *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<ISystem> 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<ISystem> Derived>
        [[nodiscard]] bool contains() const
        {
            return contains(std::type_index(typeid(Derived)));
        }
 
        void clear()
        {
            _instances.clear();
        }
 
        [[nodiscard]] constexpr const std::map<key_type, std::unique_ptr<ISystem>, Comparer> &getInner() const noexcept
        {
            return _instances;
        }
 
      private:
        std::map<key_type, std::unique_ptr<ISystem>, Comparer> _instances;
    };
} // namespace ecstasy
 
#endif /* !ECSTASY_STORAGE_SYSTEM_INSTANCES_HPP_ */