RawSerializer.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_SERIALIZATION_RAWSERIALIZER_HPP_
#define ECSTASY_SERIALIZATION_RAWSERIALIZER_HPP_
 
#include <cstdint>
#include <sstream>
#include <vector>
 
#include "Serializer.hpp"
#include "util/meta/is_std_vector.hpp"
 
namespace ecstasy::serialization
{
 
    class RawSerializer : public Serializer<RawSerializer> {
      public:
        RawSerializer() = default;
 
        RawSerializer(const std::string &content)
        {
            importBytes(content);
        }
 
        explicit RawSerializer(const std::filesystem::path &filename)
        {
            importFile(filename);
        }
 
        RawSerializer(std::istream &stream)
        {
            importStream(stream);
        }
 
        ~RawSerializer() override = default;
 
        void clear() override final
        {
            _stream.str("");
        }
 
        void resetCursors(bool read = true, bool write = true)
        {
            if (read)
                resetReadCursor();
            if (write)
                resetWriteCursor();
        }
 
        void resetReadCursor()
        {
            _stream.seekg(0);
        }
 
        void resetWriteCursor()
        {
            _stream.seekp(0);
        }
 
        [[nodiscard]] size_t size() const override final
        {
            return _stream.str().size();
        }
 
        void importStream(std::istream &stream) override final
        {
            clear();
            _stream << stream.rdbuf();
            _stream.seekp(0);
        }
 
        void exportStream(std::ostream &stream) const override final
        {
            std::stringstream &s = const_cast<std::stringstream &>(_stream);
            std::streampos pos = s.tellg();
 
            // Read from the begining of the stream
            s.seekg(0);
            stream << s.rdbuf();
            // Replace the read cursor at the original position
            s.seekg(pos);
        }
 
        // clang-format off
        template <typename T,
            typename = typename std::enable_if<
                (std::is_same_v<T, std::string> || std::is_same_v<T, std::string_view>) || // String
                std::is_bounded_array_v<T> || // Bounded array
                util::meta::is_std_vector<T>::value || // std::vector
                std::is_same_v<T, std::type_info> // std::type_info
                , int>::type >
                requires(!std::is_fundamental_v<T>)
        // clang-format on
        RawSerializer &saveImpl(const T &object)
        {
            if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, std::string_view>) {
                save(static_cast<uint32_t>(object.size()));
                _stream << object;
            } else if constexpr (std::is_bounded_array_v<T>) {
                for (size_t i = 0; i < std::extent_v<T>; i++)
                    save(object[i]);
            } else if constexpr (util::meta::is_std_vector<T>::value) {
                *this << object.size();
                for (const auto &elem : object)
                    *this << elem;
            } else if constexpr (std::is_same_v<T, std::type_info>) {
                save(rtti::TypeRegistry::getInstance().get(object).getHash());
            } else {
                return Parent::save(object);
            }
            return *this;
        }
 
        template <typename U>
            requires std::is_fundamental_v<U>
        RawSerializer &saveImpl(U object)
        {
            write(reinterpret_cast<const char *>(&object), sizeof(object));
            return *this;
        }
 
        // clang-format off
        template <typename U,
            typename = typename std::enable_if<(
                std::is_same_v<U, std::string> || // Load
                 std::is_bounded_array_v<U> || // Bounded array
                 util::meta::is_std_vector<U>::value) // std::vector
                ,
                int>::type>
        // clang-format on
        RawSerializer &updateImpl(U &object)
        {
            if constexpr (std::is_same_v<U, std::string>)
                object = load<U>();
            else if constexpr (std::is_bounded_array_v<U>)
                for (size_t i = 0; i < std::extent_v<U>; i++)
                    update(object[i]);
            else if constexpr (util::meta::is_std_vector<U>::value) {
                auto size = load<decltype(object.size())>();
                object.clear();
                object.reserve(size);
                for (size_t i = 0; i < size; i++) {
                    if constexpr (is_constructible<typename U::value_type>)
                        object.emplace_back(*this);
                    else
                        object.push_back(std::move(load<typename U::value_type>()));
                }
            } else
                return Parent::update(object);
            return *this;
        }
 
        template <typename U>
            requires std::is_fundamental_v<U> || std::is_same_v<U, std::string>
        [[nodiscard]] U loadImpl()
        {
            if constexpr (std::is_fundamental_v<U>)
                return loadRaw<U>();
            else if constexpr (std::is_same<U, std::string>::value) {
                uint32_t size = loadRaw<uint32_t>();
                std::streampos pos = _stream.tellg();
                _stream.seekg(pos + std::streamoff(size));
 
                return std::string(_stream.view().data() + pos, size);
            }
        }
 
        template <typename U>
        RawSerializer &appendRaw(const U &object)
        {
            write(reinterpret_cast<const char *>(&object), sizeof(object));
            return *this;
        }
 
        void write(const char *bytes, size_t size)
        {
            _stream.write(bytes, static_cast<std::streamsize>(size));
        }
 
        template <typename U>
        [[nodiscard]] U loadRaw()
        {
            std::streampos pos = _stream.tellg();
            const U *result = reinterpret_cast<const U *>(_stream.view().data() + pos);
            _stream.seekg(pos + std::streamoff(sizeof(U)));
            return *result;
        }
 
        [[nodiscard]] std::stringstream &getStream() noexcept
        {
            return _stream;
        }
 
      private:
        std::stringstream _stream;
 
        void afterSaveEntity([[maybe_unused]] RegistryEntity &entity) override final
        {
            // Notify the end of the entity
            save<std::size_t>(0);
        }
 
        OptionalEntityComponentSerializer loadComponentSerializer() override final
        {
            size_t hash = loadRaw<std::size_t>();
 
            if (hash == 0)
                return std::nullopt;
 
            // Will raise an exception if the serializer is not registered
            return ecstasy::rtti::TypeRegistry::getInstance().get(hash).getSerializer<RawSerializer>();
        }
    };
} // namespace ecstasy::serialization
 
#endif /* !ECSTASY_SERIALIZATION_RAWSERIALIZER_HPP_ */