feat(data): add binary serialization

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Components to support rigid body rotation (#865, **@fallenatlas**).
 - Compute contact points and contact manifold for collision between boxes (#1243, **@fallenatlas**).
 - Handle body rotation on physics integration (#1242, **&fallenatlas**).
+- Binary Serializer and Deserializer (#1306, **@RiscadoA**).
 
 ### Fixed
 

core/CMakeLists.txt

@@ -67,8 +67,10 @@ set(CUBOS_CORE_SOURCE
  "src/data/ser/serializer.cpp"
  "src/data/ser/json.cpp"
  "src/data/ser/debug.cpp"
+ "src/data/ser/binary.cpp"
  "src/data/des/deserializer.cpp"
  "src/data/des/json.cpp"
+ "src/data/des/binary.cpp"
 
  "src/io/window.cpp"
  "src/io/cursor.cpp"

core/include/cubos/core/data/des/binary.hpp

@@ -0,0 +1,27 @@
+/// @file
+/// @brief Class @ref cubos::core::data::BinaryDeserializer.
+/// @ingroup core-data-des
+
+#pragma once
+
+#include <cubos/core/data/des/deserializer.hpp>
+#include <cubos/core/memory/stream.hpp>
+
+namespace cubos::core::data
+{
+ /// @brief Implementation of the abstract Deserializer class meant to deserialize data written by a @ref
+ /// BinarySerializer.
+ class CUBOS_CORE_API BinaryDeserializer : public Deserializer
+ {
+ public:
+ /// @brief Constructs.
+ /// @param stream Stream to read from.
+ BinaryDeserializer(memory::Stream& stream);
+
+ protected:
+ bool decompose(const reflection::Type& type, void* value) override;
+
+ private:
+ memory::Stream& mStream; ///< Stream to deserialize from.
+ };
+} // namespace cubos::core::data

core/include/cubos/core/data/ser/binary.hpp

@@ -0,0 +1,27 @@
+/// @file
+/// @brief Class @ref cubos::core::data::BinarySerializer.
+/// @ingroup core-data-ser
+
+#pragma once
+
+#include <cubos/core/data/ser/serializer.hpp>
+#include <cubos/core/memory/stream.hpp>
+
+namespace cubos::core::data
+{
+ /// @brief Implementation of the abstract Serializer class meant to serialize data in a non-readable but fast and
+ /// compact way.
+ class CUBOS_CORE_API BinarySerializer : public Serializer
+ {
+ public:
+ /// @brief Constructs.
+ /// @param stream Stream to write to.
+ BinarySerializer(memory::Stream& stream);
+
+ protected:
+ bool decompose(const reflection::Type& type, const void* value) override;
+
+ private:
+ memory::Stream& mStream; ///< Stream to serialize to.
+ };
+} // namespace cubos::core::data

core/src/data/des/binary.cpp

@@ -0,0 +1,184 @@
+#include <cubos/core/data/des/binary.hpp>
+#include <cubos/core/log.hpp>
+#include <cubos/core/memory/any_value.hpp>
+#include <cubos/core/memory/endianness.hpp>
+#include <cubos/core/reflection/external/primitives.hpp>
+#include <cubos/core/reflection/external/string.hpp>
+#include <cubos/core/reflection/traits/array.hpp>
+#include <cubos/core/reflection/traits/dictionary.hpp>
+#include <cubos/core/reflection/traits/enum.hpp>
+#include <cubos/core/reflection/traits/fields.hpp>
+#include <cubos/core/reflection/traits/string_conversion.hpp>
+#include <cubos/core/reflection/type.hpp>
+
+using cubos::core::data::BinaryDeserializer;
+using cubos::core::memory::AnyValue;
+using cubos::core::reflection::ArrayTrait;
+using cubos::core::reflection::DictionaryTrait;
+using cubos::core::reflection::EnumTrait;
+using cubos::core::reflection::FieldsTrait;
+using cubos::core::reflection::StringConversionTrait;
+using cubos::core::reflection::Type;
+
+// NOLINTBEGIN(bugprone-macro-parentheses)
+#define AUTO_HOOK(casted, type) \
+ this->hook<type>([this](type& value) { \
+ casted castedValue; \
+ if (!mStream.readExact(&castedValue, sizeof(castedValue))) \
+ { \
+ return false; \
+ } \
+ value = static_cast<type>(memory::fromLittleEndian(castedValue)); \
+ return true; \
+ })
+// NOLINTEND(bugprone-macro-parentheses)
+
+BinaryDeserializer::BinaryDeserializer(memory::Stream& stream)
+ : mStream(stream)
+{
+ this->hook<bool>([this](bool& value) {
+ value = mStream.get() != '\0';
+ return !mStream.eof();
+ });
+ this->hook<char>([this](char& value) { return mStream.readExact(&value, 1); });
+
+ AUTO_HOOK(std::int8_t, signed char);
+ AUTO_HOOK(std::int16_t, short);
+ AUTO_HOOK(std::int32_t, int);
+ AUTO_HOOK(std::int64_t, long);
+ AUTO_HOOK(std::int64_t, long long);
+
+ AUTO_HOOK(std::uint8_t, unsigned char);
+ AUTO_HOOK(std::uint16_t, unsigned short);
+ AUTO_HOOK(std::uint32_t, unsigned int);
+ AUTO_HOOK(std::uint64_t, unsigned long);
+ AUTO_HOOK(std::uint64_t, unsigned long long);
+
+ AUTO_HOOK(float, float);
+ AUTO_HOOK(double, double);
+
+ this->hook<std::string>([this](std::string& value) {
+ std::size_t length;
+ if (!this->read(length))
+ {
+ return false;
+ }
+
+ value.resize(length);
+ return mStream.readExact(value.data(), length);
+ });
+}
+
+bool BinaryDeserializer::decompose(const Type& type, void* value)
+{
+ if (type.has<DictionaryTrait>())
+ {
+ const auto& trait = type.get<DictionaryTrait>();
+ auto view = trait.view(value);
+ view.clear();
+
+ std::size_t length;
+ if (!this->read(length))
+ {
+ CUBOS_ERROR("Could not deserialize dictionary length");
+ return false;
+ }
+
+ auto key = AnyValue::defaultConstruct(trait.keyType());
+ for (std::size_t i = 0; i < length; ++i)
+ {
+ if (!this->read(trait.keyType(), key.get()))
+ {
+ CUBOS_ERROR("Could not deserialize dictionary key");
+ return false;
+ }
+
+ view.insertDefault(key.get());
+ auto entry = view.find(key.get());
+ CUBOS_ASSERT(entry != view.end(), "We just inserted the entry, where did it go?");
+
+ if (!this->read(trait.valueType(), entry->value))
+ {
+ CUBOS_ERROR("Could not deserialize dictionary value");
+ return false;
+ }
+ }
+ }
+ else if (type.has<ArrayTrait>())
+ {
+ const auto& trait = type.get<ArrayTrait>();
+ auto view = trait.view(value);
+
+ std::size_t length;
+ if (!this->read(length))
+ {
+ CUBOS_ERROR("Could not deserialize array length");
+ return false;
+ }
+ view.resize(length);
+
+ for (auto* element : view)
+ {
+ if (!this->read(trait.elementType(), element))
+ {
+ CUBOS_ERROR("Could not deserialize array element");
+ return false;
+ }
+ }
+ }
+ else if (type.has<EnumTrait>())
+ {
+ const auto& trait = type.get<EnumTrait>();
+
+ std::string name;
+ if (!this->read(name))
+ {
+ CUBOS_ERROR("Could not deserialize enum");
+ return false;
+ }
+
+ if (!trait.contains(name))
+ {
+ CUBOS_ERROR("Could not deserialize enum, no such variant '{}'", name);
+ return false;
+ }
+
+ trait.at(name).set(value);
+ }
+ else if (type.has<FieldsTrait>())
+ {
+ const auto& trait = type.get<FieldsTrait>();
+ for (const auto& [field, fieldValue] : trait.view(value))
+ {
+ if (!this->read(field->type(), fieldValue))
+ {
+ CUBOS_ERROR("Could not deserialize field '{}'", field->name());
+ return false;
+ }
+ }
+ }
+ else if (type.has<StringConversionTrait>())
+ {
+ const auto& trait = type.get<StringConversionTrait>();
+
+ std::string string;
+ if (!this->read(string))
+ {
+ CUBOS_ERROR("Could not deserialize string conversion");
+ return false;
+ }
+
+ if (!trait.from(value, string))
+ {
+ CUBOS_ERROR("Could not deserialize string conversion, string '{}' is not a valid conversion", string);
+ return false;
+ }
+ }
+ else
+ {
+ CUBOS_WARN("Type {} doesn't have any of the supported traits", type.name());
+ return false;
+ }
+
+ return true;
+}