Serializer.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_SERIALIZATION_SERIALIZER_HPP_
#define ECSTASY_SERIALIZATION_SERIALIZER_HPP_
 
#include <fstream>
#include <sstream>
#include <unordered_map>
 
#include "ecstasy/resources/entity/RegistryEntity.hpp"
#include "ecstasy/serialization/EntityComponentSerializer.hpp"
#include "ecstasy/serialization/ISerializer.hpp"
#include "util/serialization/foreach.hpp"
#include "ecstasy/serialization/concepts/has_extraction_operator.hpp"
#include "ecstasy/serialization/concepts/has_insertion_operator.hpp"
#include "ecstasy/serialization/traits/can_load_type.hpp"
#include "ecstasy/serialization/traits/can_save_type.hpp"
#include "ecstasy/serialization/traits/can_update_type.hpp"
 
#include "ecstasy/rtti/TypeRegistry.hpp"
 
#define __CONCATENATE_DETAIL(x, y)      x##y
#define __CONCATENATE(x, y)             __CONCATENATE_DETAIL(x, y)
#define _REGISTER_SERIALIZABLES_AGAIN() _REGISTER_SERIALIZABLES_HELPER
#define _REGISTER_SERIALIZABLES_HELPER(COMPONENT, a1, ...) \
    REGISTER_SERIALIZABLE(COMPONENT, a1)                   \
    __VA_OPT__(_REGISTER_SERIALIZABLES_AGAIN PARENS(COMPONENT, __VA_ARGS__))
 
#define REGISTER_SERIALIZABLE(COMPONENT, SERIALIZER)                \
    static bool __CONCATENATE(registered_component_, __COUNTER__) = \
        reinterpret_cast<bool &>(SERIALIZER::registerComponent<COMPONENT>(#COMPONENT));
 
#define REGISTER_SERIALIZABLES(COMPONENT, a1, ...) EXPAND(_REGISTER_SERIALIZABLES_HELPER(COMPONENT, a1, __VA_ARGS__))
 
namespace ecstasy::serialization
{
 
    template <typename S>
    class Serializer : public ISerializer {
      protected:
        using Parent = Serializer<S>;
 
      public:
        template <typename U>
        static constexpr bool is_constructible = std::is_constructible_v<U, std::add_lvalue_reference_t<S>>;
 
        Serializer() = default;
 
        ~Serializer() override = default;
 
        constexpr S &inner()
        {
            return reinterpret_cast<S &>(*this);
        }
 
        void importFile(const std::filesystem::path &filename) override
        {
            std::ifstream fstream(filename);
 
            importStream(fstream);
        }
 
        void importBytes(const std::string &content) override
        {
            std::stringstream stream(content);
 
            importStream(stream);
        }
 
        void exportFile(const std::filesystem::path &filename) const override
        {
            std::ofstream fstream(filename);
 
            exportStream(fstream);
        }
 
        [[nodiscard]] std::string exportBytes() const override
        {
            std::stringstream stream;
 
            exportStream(stream);
            return stream.str();
        }
 
        template <typename U>
            requires concepts::has_extraction_operator<S, U> || traits::has_save_impl_for_type_v<S, U>
        S &save(const U &object)
        {
            if constexpr (traits::has_save_impl_for_type_v<S, U>)
                return inner().saveImpl(object);
            else
                return object >> inner();
        }
 
        template <typename C>
        S &saveEntityComponent(const C &component)
        {
            return inner() << typeid(C) << component;
        }
 
        template <typename... Cs>
        S &saveEntity(const RegistryEntity &entity)
        {
            S &s = inner();
            (saveEntityComponent(entity.get<Cs>()), ...);
            return s;
        }
 
        S &saveEntity(RegistryEntity &entity)
        {
            beforeSaveEntity(entity);
            auto storages = entity.getRegistry().getEntityStorages(entity);
 
            for (IStorage &storage : storages) {
                auto optional_type = ecstasy::rtti::TypeRegistry::getInstance().find(storage.getComponentTypeInfos());
 
                if (optional_type.has_value()) {
                    auto serializer = optional_type->get().tryGetSerializer<S>();
 
                    if (serializer.has_value())
                        serializer->get().save(*this, storage, entity);
                }
            }
            afterSaveEntity(entity);
            return inner();
        }
 
        template <typename U>
            requires is_constructible<U> || (std::is_default_constructible_v<U> && traits::can_update_type_v<S, U>)
            || traits::has_load_impl_for_type_v<S, U>
        [[nodiscard]] U load()
        {
            if constexpr (traits::has_load_impl_for_type_v<S, U>)
                return inner().template loadImpl<U>();
            else if constexpr (is_constructible<U>) {
                return U(inner());
            } else {
                U object;
                inner().update(object);
                return object;
            }
        }
 
        RegistryEntity loadEntity(Registry &registry)
        {
            RegistryEntity entity(registry.entityBuilder().build(), registry);
 
            updateEntity(entity);
            return entity;
        }
 
        template <typename U>
            requires traits::has_update_impl_for_type_v<S, U> || std::is_fundamental_v<U>
            || concepts::has_insertion_operator<S, U>
        S &update(U &object)
        {
            if constexpr (traits::has_update_impl_for_type_v<S, U>)
                return inner().updateImpl(object);
            else {
                if constexpr (std::is_fundamental_v<U>)
                    object = inner().template load<U>();
                else
                    object << inner();
                return inner();
            }
        }
 
        S &updateEntity(RegistryEntity &entity)
        {
            beforeUpdateEntity(entity);
            OptionalEntityComponentSerializer component = loadComponentSerializer();
 
            while (component.has_value()) {
                rtti::AType &type = rtti::TypeRegistry::getInstance().get(component->get().getType());
                IStorage &storage = entity.getRegistry().getStorages().get(std::type_index(type.getStorageTypeInfo()));
 
                component->get().load(*this, storage, entity);
 
                component = loadComponentSerializer();
            }
            afterUpdateEntity(entity);
            return inner();
        }
 
        template <typename U>
        S &operator<<(const U &object)
        {
            return inner().save(object);
        }
 
        template <typename U>
        S &operator>>(U &object)
        {
            return inner().update(object);
        }
 
        template <typename C>
        static IEntityComponentSerializer &registerComponent(std::string_view name)
        {
            rtti::AType &type = rtti::TypeRegistry::getInstance().registerType<C>(name);
 
            return dynamic_cast<rtti::Type<C> &>(type).template registerSerializer<S>();
        }
 
        template <typename T>
        [[nodiscard]] static bool hasEntityComponentSerializer()
        {
            auto atype = rtti::TypeRegistry::getInstance().find<T>();
 
            if (atype.has_value())
                return atype->get().template hasSerializer<S>();
            return false;
        }
 
      protected:
        using OptionalEntityComponentSerializer = std::optional<std::reference_wrapper<IEntityComponentSerializer>>;
 
        [[nodiscard]] virtual OptionalEntityComponentSerializer loadComponentSerializer() = 0;
 
        virtual void beforeSaveEntity([[maybe_unused]] RegistryEntity &entity)
        {
        }
 
        virtual void afterSaveEntity([[maybe_unused]] RegistryEntity &entity)
        {
        }
 
        virtual void beforeUpdateEntity([[maybe_unused]] RegistryEntity &entity)
        {
        }
 
        virtual void afterUpdateEntity([[maybe_unused]] RegistryEntity &entity)
        {
        }
    };
 
} // namespace ecstasy::serialization
 
#endif /* !ECSTASY_SERIALIZATION_SERIALIZER_HPP_ */