Les opérateurs de flux du langage c++ présentent certaines lacunes :
-Ils ne permettent pas de sérialiser et désérialiser des pointeurs ni les contenaire de la STL.
En effet, écrire l'adresse d'un pointeur dans un fichier est inutile car a deux exécutions différentes,
l'adresse de l'objet alloué peut avoir changé, alors le pointeur risque de ne plus pointé vers le bonne objet
lors de la lecture, ODFAEG possède un système qui affecte la nouvelle adresse au pointeur en associant un id à chaque adresse.
ODFAEG permet aussi de serialiser les contenaires de la STL, ainsi que des pointeurs intelligents.
Les classes qui permettent de faire cela sont les classe odfaeg::core::OTextArchive et odfaeg::core::ITextArchive.
Tout est serialiser sous forme de texte et non pas en binaire pour des raisons de compatibilité.
On peut aussi créer un type d'archive personnalisée car la méthode qui permet a odfaeg de serialiser des objets est template.
Pour serialiser un objet il faut d'abord créer un objet de type odfaeg::core::OTextArchive, le constructeur de cette classe
attend un paramètre : une référence vers un flux standart et donc un objet héritant de la classe std::ostream, prenons par exemple la classe
ofstream pour écrire dans un fichier.

La serialisation et les objets simples.

Si l'on veut sérialiser et désérialiser une chaine de caractère par exemple, il suffit d'écrire ce code :

  odfaeg::core::OTextArchive ota(file);
  ota(machaineecrite);
  odfaeg::core::ITextArchive ita(file);
  ita(machainelue);

C'est l'opérateur () qui sert à écrire ou lire du contenu dans l'archive donc.
Pour les objets, il faut définir comment les écrires, pour cela, il suffit de redéfinir la méthode serialize, qui est template:
Celle-ci prend donc en paramètre template, une référence vers l'archive dans laquelle seront serialises ou deserialise les variables
de l'objet.

  template
  void AClass::serialize(Archive& ar){
     ar(var);
  }

La serialisation et les objets polymorphiques

Pour les objets polymorphiques, vous devez redéfinir la méthode vtserialize!
Celle-ci attend aussi un paramètre template qui est une référence vers l'archive dans laquelle seront serialisée et désérialisée vos variables.

template   
void ABaseClass::vtserialize(Archive& ar) {
     ar(var);
}
template   
void ADerivedClass::vtserialize(Archive& ar) {
     ABaseClass::vtserialize(ar);
     ar(var);
}

L'une des deux méthodes vtserialize sera appelée par ODFAEG suivant le type du pointeur sur l'objet polymorphique à l'exécution!

  ABaseClass* polymorphicObject = new ADeriveClass();
  odfaeg::core::OTextArchive ota(file);
  ota(polymorphicObject);
  odfaeg::core::ITextArchive ita(file);
  ABaseClass* polymoprhicRead;
  ita(polymoprhicRead);

Il n'est pas nécessaire d'allouer le pointeur pour la lecture de l'objet polymorphique car ceci sera fait automatiquement
lors de la lecture.
Il suffit juste donc de le déclarer et le passer à l'archive de lecture.
Il y a cependant une nouveauté ici, comme ODFAEG doit créer lui même les pointeurs de fonctions vers les fonctions virtuelle
template (car en c++ les fonctions virtuelles ne peuvent pas être template), il faut que ODFAEG crée ces pointeurs de fonctions
en début de programme, pour que ODFAEG puisse appeler le bon pointeur de fonction en fonction du type de l'objet polymorphique
à l'exécution!

Pour créer ces pointeurs de fonction, il faut appeler cette macro tout au début dans la fonction main :
EXPORT_CLASS_GUID(RELATIONID, ABaseClass, ADerivedClass);
Le premier paramètre est juste l'id de la relation, le second le type de la classe de base et le troisième le type de la classe
dérivée.
Voilà c'est tout, maintenant vous savez écrire et lire n'importe quel type d'objet c++ avec ODFAEG dans un format standart
et compatible de type texte, vous pouvez aussi bien sûr les sérialiser dans des flux mémoire pour les envoyer sur le réseau
par exemple.