TypeRegistry.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_RTTI_TYPEREGISTRY_HPP_
#define ECSTASY_RTTI_TYPEREGISTRY_HPP_
 
#include <algorithm>
#include <functional>
#include <optional>
 
#include "Type.hpp"
#include "util/serialization/foreach.hpp"
 
#define CONCAT_IMPL(x, y) x##y
#define CONCAT(x, y)      CONCAT_IMPL(x, y)
 
#define REGISTER_TYPE(TYPE)                        \
    static bool CONCAT(registered_, __COUNTER__) = \
        reinterpret_cast<bool &>(ecstasy::rtti::TypeRegistry::getInstance().registerType<TYPE>(#TYPE));
 
#define REGISTER_TYPES(TYPE, ...) FOR_EACH(REGISTER_TYPE, TYPE, __VA_ARGS__)
 
namespace ecstasy::rtti
{
 
    class TypeRegistry {
      public:
        using Predicate = std::function<bool(const std::pair<const std::size_t, std::unique_ptr<AType>> &)>;
        using OptionalATypeReference = std::optional<std::reference_wrapper<AType>>;
 
        [[nodiscard]] static TypeRegistry &getInstance() noexcept;
 
        template <typename T>
        AType &registerType(std::string_view name)
        {
            size_t hash = std::hash<std::string_view>{}(name);
            OptionalATypeReference type = find(hash);
 
            if (type.has_value())
                return type.value();
            else
                return *_types.emplace(hash, std::make_unique<Type<T>>(name)).first->second;
        }
 
        template <is_comparable_with_atype T>
        [[nodiscard]] bool has(const T &target) const noexcept
        {
            return find(target).has_value();
        }
 
        [[nodiscard]] bool has(size_t name_hash) const noexcept;
 
        template <typename T>
        [[nodiscard]] bool has() const noexcept
        {
            return has<std::type_info>(typeid(T));
        }
 
        [[nodiscard]] OptionalATypeReference findIf(const Predicate &p) const noexcept;
 
        [[nodiscard]] AType &getIf(const Predicate &p) const;
 
        template <is_comparable_with_atype T>
        [[nodiscard]] OptionalATypeReference find(const T &target) const noexcept
        {
            auto result = std::find_if(_types.begin(), _types.end(), [&target](const auto &pair) {
                return *pair.second == target;
            });
 
            if (result == _types.end())
                return std::nullopt;
            return std::ref(*result->second);
        }
 
        [[nodiscard]] OptionalATypeReference find(std::size_t name_hash) const noexcept;
 
        template <typename T>
        [[nodiscard]] OptionalATypeReference find() const noexcept
        {
            return find<std::type_info>(typeid(T));
        }
 
        template <is_comparable_with_atype T>
        [[nodiscard]] AType &get(const T &target) const
        {
            auto result = find(target);
 
            if (result.has_value())
                return result.value();
            throw std::out_of_range("Type not found.");
        }
 
        [[nodiscard]] AType &get(std::size_t name_hash) const;
 
        template <typename T>
        [[nodiscard]] AType &get() const
        {
            return get<std::type_info>(typeid(T));
        }
 
      private:
        std::unordered_map<std::size_t, std::unique_ptr<AType>> _types;
 
        TypeRegistry() noexcept = default;
 
        ~TypeRegistry() noexcept = default;
    };
 
} // namespace ecstasy::rtti
 
#endif /* !ECSTASY_RTTI_TYPEREGISTRY_HPP_ */