How to serialize derived template classes with Boost.serialize?

by

First tell boost that Feature is abstract, is not always needed:

BOOST_SERIALIZATION_ASSUME_ABSTRACT(Feature);

The serialization method should look more or less like this:

template<class Archive> 
void Feature::serialize(Archive & ar, const unsigned int version)
{
   ar & BOOST_SERIALIZATION_NVP(some_member);
}


template<typename T,class Archive> 
void GenericFeature<T>::serialize(Archive & ar, const unsigned int version)
{
   ar & boost::serialization::base_object<Feature>(*this);  //serialize base class
   ar & BOOST_SERIALIZATION_NVP(some_other_member);
}

Now the tricky point is to register class in serialize/deserialize:

boost::archive::text_iarchive inputArchive(somesstream);

boost::archive::text_oarchive outputArchive(somesstream);

//something to serialize
Feature* one = new GenericFeature<SomeType1>();
Feature* two = new GenericFeature<SomeType2>();
Feature* three = new GenericFeature<SomeType3>();

//register our class, must be all of posible template specyfication    
outputArchive.template register_type< GenericFeature<SomeType1> >();
outputArchive.template register_type< GenericFeature<SomeType2> >();
outputArchive.template register_type< GenericFeature<SomeType3> >();

// now simply serialize ;-]
outputArchive << one << two << three;

// register class in deserialization
// must be the same template specification as in serialize
// and in the same correct order or i'm get it wrong ;-D   
inputArchive.template register_type< GenericFeature<SomeType1> >();
inputArchive.template register_type< GenericFeature<SomeType2> >();
inputArchive.template register_type< GenericFeature<SomeType3> >();

Feature* another_one;
Feature* another_two;
Feature* another_three;

// and deserialize ;-]
inputArchive >> another_one >> another_two >> another_three;

If you need to hide explicit registering somewhere and make it more automatic, there is idea to make special functor template that register one derived class, create all avaible and put in a single list, that one static method of class Feature would register them all. However the problem will be that you need registration for all version of archive, right now i dont know if polymorphic archive will do the job or not.

More Related Contents:

  1. Boost C++ Serialization overhead
  2. C++ Serialization Performance
  3. Get private data members for non intrusive boost serialization C++
  4. how to do performance test using the boost library for a custom library
  5. How to use Boost in Visual Studio 2010
  6. Serializing a class which contains a std::string
  7. How to create a thread pool using boost in C++?
  8. make shared_ptr not use delete
  9. when g++ static link pthread, cause Segmentation fault, why?
  10. How can I use polymorphic attributes with boost::spirit::qi parsers?
  11. How to compile/link Boost with clang++/libc++?
  12. How to filter items from a std::map? [duplicate]
  13. undefined reference to template function [duplicate]
  14. unordered_map thread safety
  15. Cancelling boost asio deadline timer safely
  16. A good example for boost::algorithm::join
  17. How to make my split work only on one real line and be capable to skip quoted parts of string?
  18. Escaping a C++ string
  19. Understanding Boost.spirit’s string parser
  20. C++ Boost: what’s the cause of this warning?
  21. xcode with boost : linker(Id) Warning about visibility settings
  22. Creating a thread pool using boost
  23. How to parse csv using boost::spirit
  24. When must you pass io_context to boost::asio::spawn? (C++)
  25. Using boost parse datetime string: With single digit hour format
  26. Using condition variable in a producer-consumer situation
  27. What are the differences between std::variant and boost::variant?
  28. Boost.Python: Wrap functions to release the GIL
  29. asio How to change the executor inside an awaitable?
  30. How can I extend a lexical cast to support enumerated types?

Leave a Comment