AType.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_RTTI_ATYPE_HPP_
#define ECSTASY_RTTI_ATYPE_HPP_
 
#include <optional>
#include <typeindex>
#include <string_view>
#include <type_traits>
#include <unordered_map>
 
#include "ecstasy/serialization/ISerializer.hpp"
 
namespace ecstasy
{
    namespace serialization
    {
        class IEntityComponentSerializer;
    }
 
    namespace rtti
    {
        class AType {
          public:
            virtual ~AType() noexcept = default;
 
            [[nodiscard]] virtual const std::type_info &getStorageTypeInfo() const noexcept = 0;
 
            [[nodiscard]] virtual const std::type_info &getTypeInfo() const noexcept = 0;
 
            [[nodiscard]] virtual size_t getHash() const noexcept = 0;
 
            [[nodiscard]] virtual std::string_view getTypeName() const noexcept = 0;
 
            [[nodiscard]] std::strong_ordering operator<=>(const AType &rhs) const noexcept;
 
            [[nodiscard]] bool operator==(const AType &rhs) const noexcept;
 
            [[nodiscard]] bool operator==(const std::type_info &rhs) const noexcept;
 
            [[nodiscard]] bool operator==(const std::string_view &rhs) const noexcept;
 
            template <std::derived_from<ecstasy::serialization::ISerializer> Serializer>
            [[nodiscard]] bool hasSerializer() const noexcept
            {
                return _serializers.contains(std::type_index(typeid(Serializer)));
            }
 
            template <std::derived_from<ecstasy::serialization::ISerializer> Serializer>
            [[nodiscard]] ecstasy::serialization::IEntityComponentSerializer &getSerializer() const noexcept
            {
                return *_serializers.at(std::type_index(typeid(Serializer)));
            }
 
            template <std::derived_from<ecstasy::serialization::ISerializer> Serializer>
            [[nodiscard]] std::optional<std::reference_wrapper<ecstasy::serialization::IEntityComponentSerializer>>
            tryGetSerializer() const noexcept
            {
                auto res = _serializers.find(std::type_index(typeid(Serializer)));
                if (res != _serializers.end())
                    return std::ref(*res->second);
                return std::nullopt;
            }
 
          protected:
            std::unordered_map<std::type_index, std::unique_ptr<ecstasy::serialization::IEntityComponentSerializer>>
                _serializers;
        };
 
        template <typename T>
        concept is_comparable_with_atype = requires(AType &a, T t) {
            {
                a == t
            } -> std::convertible_to<bool>; // Ensure a == t returns a boolean-like result
        };
 
    } // namespace rtti
} // namespace ecstasy
 
#endif /* !ECSTASY_RTTI_ATYPE_HPP_ */