BinarySerializer.h

/*
 * GDevelop Core
 * Copyright 2008-present Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
 
#pragma once
 
#include <cstdint>
#include <cstring>
#include <vector>
 
#include "GDCore/Serialization/SerializerElement.h"
 
namespace gd {
 
class GD_CORE_API BinarySerializer {
 public:
  static void SerializeToBinaryBuffer(const SerializerElement& element,
                                std::vector<uint8_t>& outBuffer);
 
  static bool DeserializeFromBinaryBuffer(const uint8_t* buffer,
                                    size_t bufferSize,
                                    SerializerElement& outElement);
 
 
  static uintptr_t CreateBinarySnapshot(const SerializerElement& element);
 
  static size_t GetLastBinarySnapshotSize();
 
  static void FreeBinarySnapshot(uintptr_t bufferPtr);
 
  static SerializerElement* DeserializeBinarySnapshot(uintptr_t bufferPtr,
                                                       size_t size);
 
  enum class NodeType : uint8_t {
    Element = 0x01,
    ValueUndefined = 0x02,
    ValueBool = 0x03,
    ValueInt = 0x04,
    ValueDouble = 0x05,
    ValueString = 0x06
  };
 
 private:
  // Internal serialization
  static void SerializeElement(const SerializerElement& element,
                               std::vector<uint8_t>& buffer);
  static void SerializeValue(const SerializerValue& value,
                             std::vector<uint8_t>& buffer);
  static void SerializeString(const gd::String& str,
                              std::vector<uint8_t>& buffer);
 
  // Internal deserialization
  static bool DeserializeElement(const uint8_t*& ptr,
                                 const uint8_t* end,
                                 SerializerElement& element);
  static bool DeserializeValue(const uint8_t*& ptr,
                               const uint8_t* end,
                               SerializerValue& value,
                               NodeType valueType);
  static bool DeserializeString(const uint8_t*& ptr,
                                const uint8_t* end,
                                gd::String& str);
 
  // Helper to write primitive types
  template <typename T>
  static void Write(std::vector<uint8_t>& buffer, const T& value) {
    const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&value);
    buffer.insert(buffer.end(), bytes, bytes + sizeof(T));
  }
 
  // Helper to read primitive types
  template <typename T>
  static bool Read(const uint8_t*& ptr, const uint8_t* end, T& value) {
    if (ptr + sizeof(T) > end) return false;
    std::memcpy(&value, ptr, sizeof(T));
    ptr += sizeof(T);
    return true;
  }
 
  // Store the last binary size for retrieval
  static size_t lastBinarySnapshotSize;
};
 
}  // namespace gd