Commit 9c84ffcc authored by Filip Hauzvic's avatar Filip Hauzvic
Browse files

Update serialization to use com functions

parent 15128490

utils/include/utils/serialization.hpp

+53 −44
Original line number Diff line number Diff line
@@ -32,6 +32,22 @@ inline Deserializer create_deserializer(const Buffer& buffer) 
    return Deserializer{InputAdapter{buffer.cbegin(), buffer.cend()}};

}



inline void serialize_path(Serializer& s, const std::vector<std::string>& path)

{

    s.container(path, MAX_PATH_DEPTH, [](auto& s, std::string& str)

    {

        s.text1b(str, MAX_STRING_LENGTH);

    });

}



inline void deserialize_path(Deserializer& s, std::vector<std::string>& path)

{

    s.container(path, MAX_PATH_DEPTH, [](auto& s, std::string& str)

    {

        s.text1b(str, MAX_STRING_LENGTH);

    });

}



inline void serialize_reflection_value(Serializer& s, const com::Reflection::ValuePtr& value)

{

    s.value1b(static_cast<uint8_t>(value->typeID()));
@@ -39,46 +55,49 @@ inline void serialize_reflection_value(Serializer& s, const com::Reflection::Val 
    switch (value->typeID())

    {

    case com::Reflection::TypeID::BOOL:

        s.value1b(std::static_pointer_cast<com::Reflection::ValueBOOL>(value)->value);

        s.value1b(com::as<com::Reflection::ValueBOOL>(value)->value);

        break;

    case com::Reflection::TypeID::INT:

        s.value4b(std::static_pointer_cast<com::Reflection::ValueINT>(value)->value);

        s.value4b(com::as<com::Reflection::ValueINT>(value)->value);

        break;

    case com::Reflection::TypeID::UINT:

        s.value4b(std::static_pointer_cast<com::Reflection::ValueUINT>(value)->value);

        s.value4b(com::as<com::Reflection::ValueUINT>(value)->value);

        break;

    case com::Reflection::TypeID::FLOAT:

        s.value4b(std::static_pointer_cast<com::Reflection::ValueFLOAT>(value)->value);

        s.value4b(com::as<com::Reflection::ValueFLOAT>(value)->value);

        break;

    case com::Reflection::TypeID::STRING:

        s.text1b(std::static_pointer_cast<com::Reflection::ValueSTRING>(value)->value, MAX_STRING_LENGTH);

        s.text1b(com::as<com::Reflection::ValueSTRING>(value)->value, MAX_STRING_LENGTH);

        break;

    case com::Reflection::TypeID::VEC2:

        s.object(std::static_pointer_cast<com::Reflection::ValueVEC2>(value)->value);

        s.object(com::as<com::Reflection::ValueVEC2>(value)->value);

        break;

    case com::Reflection::TypeID::VEC2I:

        s.object(std::static_pointer_cast<com::Reflection::ValueVEC2I>(value)->value);

        s.object(com::as<com::Reflection::ValueVEC2I>(value)->value);

        break;

    case com::Reflection::TypeID::VEC2U:

        s.object(std::static_pointer_cast<com::Reflection::ValueVEC2U>(value)->value);

        s.object(com::as<com::Reflection::ValueVEC2U>(value)->value);

        break;

    case com::Reflection::TypeID::VEC3:

        s.object(std::static_pointer_cast<com::Reflection::ValueVEC3>(value)->value);

        s.object(com::as<com::Reflection::ValueVEC3>(value)->value);

        break;

    case com::Reflection::TypeID::VEC3I:

        s.object(std::static_pointer_cast<com::Reflection::ValueVEC3I>(value)->value);

        s.object(com::as<com::Reflection::ValueVEC3I>(value)->value);

        break;

    case com::Reflection::TypeID::VEC3U:

        s.object(std::static_pointer_cast<com::Reflection::ValueVEC3U>(value)->value);

        s.object(com::as<com::Reflection::ValueVEC3U>(value)->value);

        break;

    case com::Reflection::TypeID::VEC4:

        s.object(std::static_pointer_cast<com::Reflection::ValueVEC4>(value)->value);

        s.object(com::as<com::Reflection::ValueVEC4>(value)->value);

        break;

    case com::Reflection::TypeID::VEC4I:

        s.object(std::static_pointer_cast<com::Reflection::ValueVEC4I>(value)->value);

        s.object(com::as<com::Reflection::ValueVEC4I>(value)->value);

        break;

    case com::Reflection::TypeID::VEC4U:

        s.object(std::static_pointer_cast<com::Reflection::ValueVEC4U>(value)->value);

        s.object(com::as<com::Reflection::ValueVEC4U>(value)->value);

        break;

    case com::Reflection::TypeID::PATH:

        serialize_path(s, com::as<com::Reflection::ValuePATH>(value)->value);

        break;

    // Handle other types if needed

    default:
@@ -97,106 +116,96 @@ inline com::Reflection::ValuePtr deserialize_reflection_value(Deserializer& s) 
        {

            bool value;

            s.value1b(value);

            return std::make_shared<com::Reflection::ValueBOOL>(value);

            return com::make_value<com::Reflection::ValueBOOL>(value);

        }

    case com::Reflection::TypeID::INT:

        {

            int32_t value;

            s.value4b(value);

            return std::make_shared<com::Reflection::ValueINT>(value);

            return com::make_value<com::Reflection::ValueINT>(value);

        }

    case com::Reflection::TypeID::UINT:

        {

            uint32_t value;

            s.value4b(value);

            return std::make_shared<com::Reflection::ValueUINT>(value);

            return com::make_value<com::Reflection::ValueUINT>(value);

        }

    case com::Reflection::TypeID::FLOAT:

        {

            float value;

            s.value4b(value);

            return std::make_shared<com::Reflection::ValueFLOAT>(value);

            return com::make_value<com::Reflection::ValueFLOAT>(value);

        }

    case com::Reflection::TypeID::STRING:

        {

            std::string value;

            s.text1b(value, MAX_STRING_LENGTH);

            return std::make_shared<com::Reflection::ValueSTRING>(value);

            return com::make_value<com::Reflection::ValueSTRING>(value);

        }

    case com::Reflection::TypeID::VEC2:

        {

            vec2 value;

            s.object(value);

            return std::make_shared<com::Reflection::ValueVEC2>(value);

            return com::make_value<com::Reflection::ValueVEC2>(value);

        }

    case com::Reflection::TypeID::VEC2I:

        {

            vec2i value;

            s.object(value);

            return std::make_shared<com::Reflection::ValueVEC2I>(value);

            return com::make_value<com::Reflection::ValueVEC2I>(value);

        }

    case com::Reflection::TypeID::VEC2U:

        {

            vec2u value;

            s.object(value);

            return std::make_shared<com::Reflection::ValueVEC2U>(value);

            return com::make_value<com::Reflection::ValueVEC2U>(value);

        }

    case com::Reflection::TypeID::VEC3:

        {

            vec3 value;

            s.object(value);

            return std::make_shared<com::Reflection::ValueVEC3>(value);

            return com::make_value<com::Reflection::ValueVEC3>(value);

        }

    case com::Reflection::TypeID::VEC3I:

        {

            vec3i value;

            s.object(value);

            return std::make_shared<com::Reflection::ValueVEC3I>(value);

            return com::make_value<com::Reflection::ValueVEC3I>(value);

        }

    case com::Reflection::TypeID::VEC3U:

        {

            vec3u value;

            s.object(value);

            return std::make_shared<com::Reflection::ValueVEC3U>(value);

            return com::make_value<com::Reflection::ValueVEC3U>(value);

        }

    case com::Reflection::TypeID::VEC4:

        {

            vec4 value;

            s.object(value);

            return std::make_shared<com::Reflection::ValueVEC4>(value);

            return com::make_value<com::Reflection::ValueVEC4>(value);

        }

    case com::Reflection::TypeID::VEC4I:

        {

            vec4i value;

            s.object(value);

            return std::make_shared<com::Reflection::ValueVEC4I>(value);

            return com::make_value<com::Reflection::ValueVEC4I>(value);

        }

    case com::Reflection::TypeID::VEC4U:

        {

            vec4u value;

            s.object(value);

            return std::make_shared<com::Reflection::ValueVEC4U>(value);

            return com::make_value<com::Reflection::ValueVEC4U>(value);

        }

    case com::Reflection::TypeID::PATH:

        {

            com::ContextPath value;

            deserialize_path(s, value);

            return com::make_value<com::Reflection::ValuePATH>(value);

        }

    default:

        throw std::runtime_error("Unsupported type for deserialization");

    }

}



inline void serialize_path(Serializer& s, const std::vector<std::string>& path)

{

    s.container(path, MAX_PATH_DEPTH, [](auto& s, std::string& str)

    {

        s.text1b(str, MAX_STRING_LENGTH);

    });

}



inline void deserialize_path(Deserializer& s, std::vector<std::string>& path)

{

    s.container(path, MAX_PATH_DEPTH, [](auto& s, std::string& str)

    {

        s.text1b(str, MAX_STRING_LENGTH);

    });

}

}



// Register serialization for custom types