Into what types can serialization be divided?

Serialization can be divided into the following fundamental types based on the method of data representation:

• Text-based: Data is represented in a human-readable format, most often as strings.

  • Advantages: Easy debugging, architecture independence.
  • Disadvantages: Larger data size, parsing required.
  • Examples: JSON, XML, YAML.

• Binary: Data is represented in a raw, binary format.

  • Advantages: Compactness, high speed of serialization/deserialization.
  • Disadvantages: Data reading is difficult without a schema, potential compatibility issues between different architectures (e.g., endianness).
  • Examples: Protocol Buffers, Apache Thrift, Cap'n Proto, MessagePack.

Additionally, serialization can be classified by the method of application:

• Manual: The developer explicitly writes code to convert object data to bytes and back.

  • Example:

  // Example of manual serialization of int
  int data = 12345;
  std::vector<char> buffer;
  buffer.resize(sizeof(int));
  std::memcpy(buffer.data(), &data, sizeof(int));
  

• Automatic (reflection/code generation): Libraries or tools are used that automatically perform serialization/deserialization based on data structure information.

  • Example: Using libraries like Boost.Serialization, cereal, RapidJSON (with custom adapters), or code generation tools for Protocol Buffers.

  // Example of using boost::serialization
  #include <boost/archive/binary_oarchive.hpp>
  #include <boost/archive/binary_iarchive.hpp>
  #include <fstream>
  #include <iostream>
  
  struct MyData {
      int x;
      double y;
  
      template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
      {
          ar & x;
          ar & y;
      }
  };
  
  void save(const MyData& data, const std::string& filename) {
      std::ofstream ofs(filename);
      boost::archive::binary_oarchive oa(ofs);
      oa << data;
  }
  
  void load(MyData& data, const std::string& filename) {
      std::ifstream ifs(filename);
      boost::archive::binary_iarchive ia(ifs);
      ia >> data;
  }
  

It is also important to consider:

• Schema-based vs Schemaless: Whether explicit data structure definition (schema) is required or the data format is self-describing.
• Streaming vs Buffered: Whether serialization can occur as data is received or if the entire data volume must be in memory before serialization/deserialization.