In welke soorten kan serialisatie worden verdeeld…

Serialisatie kan worden onderverdeeld in de volgende fundamentele typen, afhankelijk van de manier waarop gegevens worden weergegeven:

Tekstueel: Gegevens worden weergegeven in een leesbaar formaat, meestal in de vorm van strings.
- Voordelen: Gemakkelijke debugging, onafhankelijkheid van architectuur.
- Nadelen: Groter gegevensvolume, parsing vereist.
- Voorbeelden: JSON, XML, YAML.
Binaire: Gegevens worden weergegeven in een rauw, binair formaat.
- Voordelen: Compactheid, hoge snelheid van serialisatie/deserialisatie.
- Nadelen: Moeilijk lezen zonder schema, mogelijke compatibiliteitsproblemen tussen verschillende architecturen (bijvoorbeeld endianness).
- Voorbeelden: Protocol Buffers, Apache Thrift, Cap'n Proto, MessagePack.

Daarnaast kan serialisatie worden gecategoriseerd op basis van de toepassingsmethode:

Handmatig: Ontwikkelaar schrijft expliciet code om de gegevens van het object naar bytes te converteren en vice versa.

Voorbeeld:

// Handmatig serialisatievoorbeeld van int
int data = 12345;
std::vector<char> buffer;
buffer.resize(sizeof(int));
std::memcpy(buffer.data(), &data, sizeof(int));

Automatisch (reflectie/codegeneratie): Gebruikt bibliotheken of tools die automatisch serialisatie/deserialisatie uitvoeren op basis van informatie over de datastructuur.

Voorbeeld: Gebruik van bibliotheken zoals Boost.Serialization, cereal, RapidJSON (met aangepaste adapters), of codegeneratietools voor Protocol Buffers.

// Voorbeeld van gebruik van 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;
}

Daarnaast is het belangrijk om rekening te houden met:

Schema vs Schema-loos: Is een expliciete definitie van de datastructuur (schema) vereist of is het gegevensformaat zelfbeschrijvend?
Stream- vs Buffergebaseerd: Kan serialisatie plaatsvinden terwijl gegevens worden ontvangen, of moet de volledige gegevenshoeveelheid in het geheugen worden geladen voordat serialisatie/deserialisatie plaatsvindt?

In welke soorten kan serialisatie worden verdeeld?