JsonSerializer.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_SERIALIZATION_JSONSERIALIZER_HPP_
#define ECSTASY_SERIALIZATION_JSONSERIALIZER_HPP_
 
#include <cstdint>
#include <rapidjson/document.h>
#include <rapidjson/istreamwrapper.h>
#include <rapidjson/ostreamwrapper.h>
#include <rapidjson/pointer.h>
#include <rapidjson/writer.h>
#include <sstream>
#include <stack>
#include <vector>
 
#include "Serializer.hpp"
#include "util/meta/is_std_vector.hpp"
#include "util/meta/is_type_bounded_array.hpp"
 
namespace ecstasy::serialization
{
 
    class JsonSerializer : public Serializer<JsonSerializer> {
      public:
        enum class NestedContextOp {
            NewObject, 
            NewArray,  
            Close      
        };
        static constexpr NestedContextOp NewObject = NestedContextOp::NewObject;
        static constexpr NestedContextOp NewArray = NestedContextOp::NewArray;
        static constexpr NestedContextOp Close = NestedContextOp::Close;
 
        JsonSerializer()
        {
            _document.SetArray();
        };
 
        JsonSerializer(const std::string &content)
        {
            importBytes(content);
        }
 
        explicit JsonSerializer(const std::filesystem::path &filename)
        {
            importFile(filename);
        }
 
        JsonSerializer(std::istream &stream)
        {
            importStream(stream);
        }
 
        ~JsonSerializer() override = default;
 
        void clear() override final
        {
            _document.Clear();
            _document.SetArray();
        }
 
        [[nodiscard]] size_t size() const override final
        {
            return exportBytes().size();
        }
 
        void importStream(std::istream &stream) override final
        {
            rapidjson::IStreamWrapper isw(stream);
 
            clear();
            _document.ParseStream(isw);
        }
 
        void exportStream(std::ostream &stream) const override final
        {
            rapidjson::OStreamWrapper osw(stream);
            rapidjson::Writer<rapidjson::OStreamWrapper> writer(osw);
 
            _document.Accept(writer);
        }
 
        void resetCursor()
        {
            while (!_stack.empty())
                _stack.pop();
            while (!_arrayIterators.empty())
                _arrayIterators.pop();
        }
 
        // 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_fundamental_v<T> || // Fundamental type (int, float, etc.)
                std::is_same_v<T, std::type_info> || // std::type_info
                std::is_same_v<T, NestedContextOp> // Nested context operation
                , int>::type >
        // clang-format on
        JsonSerializer &saveImpl(const T &object)
        {
            if constexpr (std::is_same_v<T, NestedContextOp>) {
                switch (object) {
                    case NestedContextOp::NewObject: newNestedObject(); break;
                    case NestedContextOp::NewArray: newNestedArray(); break;
                    case NestedContextOp::Close: closeNested(); break;
                }
            } else if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, std::string_view>
                || util::meta::is_type_bounded_array_v<T, char>) {
                rapidjson::Value value;
 
                if constexpr (std::is_same_v<T, std::string>)
                    value.SetString(
                        object.c_str(), static_cast<rapidjson::SizeType>(object.length()), _document.GetAllocator());
                else if constexpr (std::is_same_v<T, std::string_view>)
                    value.SetString(
                        object.data(), static_cast<rapidjson::SizeType>(object.length()), _document.GetAllocator());
                else
                    value.SetString(object, _document.GetAllocator());
 
                addValue(std::move(value.Move()));
            } else if constexpr (std::is_bounded_array_v<T>) {
                rapidjson::Value array(rapidjson::kArrayType);
 
                for (size_t i = 0; i < std::extent_v<T>; i++)
                    array.PushBack(object[i], _document.GetAllocator());
                addValue(std::move(array.Move()));
            } else if constexpr (util::meta::is_std_vector<T>::value) {
                rapidjson::Value array(rapidjson::kArrayType);
 
                for (const auto &elem : object)
                    array.PushBack(elem, _document.GetAllocator());
                addValue(std::move(array.Move()));
            } else if constexpr (std::is_same_v<T, std::type_info>) {
                // Will raise an exception if the serializer is not registered
                rtti::AType &type = rtti::TypeRegistry::getInstance().get(object);
 
                if (getWriteCursor().IsObject()) {
                    save(type.getTypeName());
                } else
                    save(type.getHash());
            } else if constexpr (std::is_fundamental_v<T>) {
                addValue(rapidjson::Value(object));
            } else {
                return Parent::save(object);
            }
            return *this;
        }
 
        template <typename U>
            requires std::is_same_v<U, NestedContextOp>
        JsonSerializer &updateImpl(const U &object)
        {
            switch (object) {
                case NestedContextOp::NewObject: newNestedObject(false); break;
                case NestedContextOp::NewArray: newNestedArray(false); break;
                case NestedContextOp::Close: closeNested(); break;
            }
            return *this;
        }
 
        // clang-format off
        template <typename U,
            typename = typename std::enable_if<(
                std::is_same_v<U, std::string> || std::is_same_v<U, std::string_view> || // Load
                std::is_bounded_array_v<U> || // Bounded array
                util::meta::is_std_vector<U>::value) // std::vector
                , int>::type>
        // clang-format on
        JsonSerializer &updateImpl(U &object)
        {
            // Handle string key for object values
            if constexpr (std::is_same_v<U, std::string> || std::is_same_v<U, std::string_view>
                || util::meta::is_type_bounded_array_v<U, char>) {
                if (getWriteCursor().IsObject() && _nextKey.empty())
                    _nextKey = object;
                else {
                    if constexpr (std::is_same_v<U, std::string>)
                        object = load<U>();
                    else
                        throw std::invalid_argument("string_view and char[] can only be used for object keys.");
                }
            }
            // Handle bounded arrays
            else if constexpr (std::is_bounded_array_v<U>) {
                newNestedArray(false);
 
                // Need to fetch the new cursor after the new nested array
                if (getWriteCursor().Size() != std::extent_v<U>)
                    throw std::invalid_argument("Array size mismatch.");
 
                for (size_t i = 0; i < std::extent_v<U>; i++)
                    update(object[i]);
                closeNested();
            }
            // Handle std::vector
            else if constexpr (util::meta::is_std_vector<U>::value) {
                newNestedArray(false);
                rapidjson::SizeType size = getWriteCursor().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>()));
                }
                closeNested();
            } else
                return Parent::update(object);
            return *this;
        }
 
        // clang-format off
        template <typename U>
            requires std::is_fundamental_v<U> || // Fundamental type
            std::is_same_v<U, std::string>
        // clang-format on
        [[nodiscard]] U loadImpl()
        {
            const rapidjson::Value &value = readCurrentValue(true);
 
            // Read Boolean
            if constexpr (std::is_same_v<U, bool>) {
                return value.GetBool();
            }
            // Read Integer
            else if constexpr (std::numeric_limits<U>::is_integer) {
                if constexpr (std::numeric_limits<U>::is_signed) {
                    if constexpr (sizeof(U) < 8)
                        return static_cast<U>(value.GetInt());
                    else
                        return static_cast<U>(value.GetInt64());
                } else {
                    if constexpr (sizeof(U) < 8)
                        return static_cast<U>(value.GetUint());
                    else
                        return static_cast<U>(value.GetUint64());
                }
            }
            // Read Floating point
            else if constexpr (std::is_floating_point_v<U>) {
                if constexpr (sizeof(U) == 4)
                    return value.GetFloat();
                else
                    return value.GetDouble();
            }
            // Read String
            else if constexpr (std::is_same_v<U, std::string>) {
                return std::string(value.GetString(), value.GetStringLength());
            }
        }
 
        [[nodiscard]] rapidjson::Value &readCurrentValue(bool andMoveCursor = true)
        {
            rapidjson::Value &cursor = getWriteCursor();
 
            if (cursor.IsObject()) {
                if (_nextKey.empty())
                    throw std::invalid_argument("No key set for object value.");
                rapidjson::Value &result = cursor[_nextKey.c_str()];
                if (andMoveCursor)
                    _nextKey.clear();
                return result;
            } else {
                if (!cursor.IsArray()) {
                    throw std::invalid_argument("Invalid cursor type. Expected object or array.");
                }
                // If the array is empty, push the first element (first document element)
                if (_arrayIterators.empty())
                    _arrayIterators.push(cursor.Begin());
 
                // If we reached the end of the array, throw an exception
                if (_arrayIterators.top() == cursor.End())
                    throw std::out_of_range("End of array reached.");
 
                rapidjson::Value *value = _arrayIterators.top();
                // Move the cursor to the next element
                if (andMoveCursor)
                    ++_arrayIterators.top();
                return *value;
            }
        }
 
        JsonSerializer &newNested(rapidjson::Type type, bool create = true)
        {
            if (type != rapidjson::kObjectType && type != rapidjson::kArrayType)
                throw std::invalid_argument("Invalid type for nested object.");
 
            if (create) {
                rapidjson::Value &cursor = getWriteCursor();
                std::string key = _nextKey;
 
                addValue(rapidjson::Value(type));
                if (cursor.IsArray())
                    _stack.push(cursor[cursor.Size() - 1]);
                else
                    _stack.push(cursor[key.c_str()]);
            } else {
                _stack.push(readCurrentValue());
                if (getWriteCursor().IsArray())
                    _arrayIterators.push(getWriteCursor().Begin());
            }
            return *this;
        }
 
        JsonSerializer &newNestedObject(bool create = true)
        {
            return newNested(rapidjson::kObjectType, create);
        }
 
        JsonSerializer &newNestedArray(bool create = true)
        {
            return newNested(rapidjson::kArrayType, create);
        }
 
        JsonSerializer &closeNested()
        {
            if (_stack.top().get().IsArray() && !_arrayIterators.empty())
                _arrayIterators.pop();
            _stack.pop();
            return *this;
        }
 
        [[nodiscard]] rapidjson::Value &getWriteCursor() noexcept
        {
            if (_stack.empty())
                return _document;
            return _stack.top();
        }
 
        JsonSerializer &addValue(rapidjson::Value &&value)
        {
            rapidjson::Value &cursor = getWriteCursor();
 
            if (cursor.IsObject()) {
                if (_nextKey.empty()) {
                    if (value.IsString())
                        _nextKey = value.GetString();
                    else
                        throw std::logic_error("Json object key is missing.");
                } else {
                    cursor.AddMember(
                        rapidjson::Value(_nextKey.c_str(), _document.GetAllocator()), value, _document.GetAllocator());
                    _nextKey.clear();
                }
            } else {
                cursor.PushBack(value, _document.GetAllocator());
            }
            return *this;
        }
 
        bool isArrayEnd()
        {
            rapidjson::Value &cursor = getWriteCursor();
 
            if (!cursor.IsArray()) {
                throw std::invalid_argument("Invalid cursor type. Expected object or array.");
            }
            // If the array is empty, push the first element (first document element)
            if (_arrayIterators.empty())
                _arrayIterators.push(cursor.Begin());
            return _arrayIterators.top() == cursor.End();
        }
 
        size_t getArraySize()
        {
            rapidjson::Value &cursor = getWriteCursor();
 
            if (!cursor.IsArray()) {
                throw std::invalid_argument("Invalid cursor type. Expected object or array.");
            }
            return cursor.Size();
        }
 
      private:
        rapidjson::Document _document;
        std::stack<std::reference_wrapper<rapidjson::Value>> _stack;
        std::stack<rapidjson::Value::ValueIterator> _arrayIterators;
        std::stack<rapidjson::Value::MemberIterator> _objectIterators;
        std::string _nextKey;
 
        [[nodiscard]] OptionalEntityComponentSerializer loadComponentSerializer() override final
        {
            if (getWriteCursor().IsObject()) {
                if (_objectIterators.empty())
                    throw std::logic_error(
                        "No object iterator. This function should be called in an updateEntity context.");
                if (_objectIterators.top() == getWriteCursor().MemberEnd())
                    return std::nullopt;
                _nextKey = _objectIterators.top()->name.GetString();
                ++_objectIterators.top();
                return ecstasy::rtti::TypeRegistry::getInstance().get(_nextKey).getSerializer<JsonSerializer>();
            } else
                return ecstasy::rtti::TypeRegistry::getInstance()
                    .get(load<std::size_t>())
                    .getSerializer<JsonSerializer>();
        }
 
        void beforeSaveEntity([[maybe_unused]] RegistryEntity &entity) override final
        {
            newNestedObject();
        }
 
        void afterSaveEntity([[maybe_unused]] RegistryEntity &entity) override final
        {
            closeNested();
        }
 
        void beforeUpdateEntity([[maybe_unused]] RegistryEntity &entity) override final
        {
            newNestedObject(false);
            _objectIterators.push(getWriteCursor().MemberBegin());
        }
 
        void afterUpdateEntity([[maybe_unused]] RegistryEntity &entity) override final
        {
            _objectIterators.pop();
            closeNested();
        }
    };
} // namespace ecstasy::serialization
 
#endif /* !ECSTASY_SERIALIZATION_JSONSERIALIZER_HPP_ */