Comment modifier la sérialisation d'enums par défaut dans Boost.Serialization

Question

Par défaut dans Boost.Serialization, les types d'énumération sont sérialisés en tant qu'entier entier de 32 bits. Mais j'ai besoin de sérialiser certains types enum comme des entiers de largeur différente. J'ai essayé de spécialiser la méthode boost :: serialization :: serialize, mais il semble que cela ne fonctionne pas pour enums.

Voici ma tentative:

#include <iostream> 
#include <boost/archive/binary_oarchive.hpp> 
#include <boost/asio.hpp> 

enum MyEnum_t 
{ 
    HELLO, BYE 
}; 

namespace boost 
{ 
namespace serialization 
{ 

template< class Archive > 
void save(Archive & ar, const MyEnum_t & t, unsigned int version) 
{ 
    unsigned char c = (unsigned char) t; 
    ar & c; 
} 

template< class Archive > 
void load(Archive & ar, MyEnum_t & t, unsigned int version) 
{ 
    unsigned char c; 
    ar & c; 
    t = (MyEnum_t) c; 
} 

} // namespace serialization 
} // namespace boost 

BOOST_SERIALIZATION_SPLIT_FREE(MyEnum_t) 

int main(int argc, const char *argv[]) 
{ 
    boost::asio::streambuf buf; 
    boost::archive::binary_oarchive pboa(buf); 

    buf.consume(buf.size()); // Ignore headers 

    MyEnum_t me = HELLO; 
    pboa << me; 

    std::cout << buf.size() << std::endl; // buf.size() = 4, but I want 1 

    return 0; 
} 

Answer 1

Cela ne fonctionnera probablement pas parce que les énumérations ne sont pas un type réel, je ne pense pas que vous pouvez en surcharge générale une fonction pour une ENUM spécifique.

Vous pouvez accomplir ce que vous voulez en effectuant la conversion en caractère dans la sérialisation de tout objet contenant votre MyEnum_t. Vous pouvez également faire ce que Dan a suggéré et encapsuler l'énumération dans un type de première classe pour lequel vous pouvez surcharger la sérialisation. Quelque chose comme:

class MyEnum_clone { 
    unsigned char v_; 
    MyEnum_clone(MyEnum_t v) : v_(v) {}; 
    operator MyEnum_t() const {return MyEnum_t(v_); }; 

    // serialization... 
}; 

Cela ne sera probablement toujours pas complètement transparent, cependant.

Cependant, je ne vois pas pourquoi vous vous souciez de la façon dont le type est sérialisé. N'est-ce pas le point de sérialiser que vous n'avez pas à vous soucier de la représentation interne de la sérialisation, tant que vous pouvez restaurer l'objet correctement. La représentation interne semble être une propriété de l'archive.