"unregistered void cast" using boost serialiazation derived to base class

Question

I am on my second attempt to setup polymorphic serialization using the boost library. I am using this as a learning experience, but I may be a little in over my head and I am considering going back to coding the serialization myself rather than boost. Or switch to learning the vistor message Sehe showed me in a previous post.

The issue I am seeing is "unregistered void cast"

I am using shared library linking for the boost serialization library

aTodo.h:

#ifndef ATODO_H
#define ATODO_H
#include <boost/serialization/export.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/unique_ptr.hpp>

#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/stream.hpp>

class aTodo{
  public: 
   static const unsigned _Type=0x00;
   virtual ~aTodo(){};
   virtual void Do()=0;
   virtual unsigned getInitType(){return _Type;};

   private:
   friend class boost::serialization::access;
   template  <class Ar> void serialize(Ar &, unsigned){};
};
#endif

todoExec.h:

 #ifndef ATODOEXEC_H
#define ATODOEXEC_H
#include "aTodo.h"
class todoExec : public aTodo{
   public:
   static const unsigned _TYPE= 0x01;
      todoExec(std::string const & command=""):_command(command){};
      virtual unsigned getInitType(){return  _TYPE;};
      virtual void Do(){std::cout << "foo:" << getCommand() << std::endl;};
      std::string getCommand() const {return _command;};
   protected:

   private: 
      friend class boost::serialization::access;
      template <class Archive> void serilize(Archive & ar, unsigned){
         boost::serialization::void_cast_register<todoExec,aTodo>();
         boost::serialization::base_object<aTodo>(*this);
         ar& _command;
      }  
   std::string _command;
};
#endif

todoFactory.h:

#ifndef TODOFACTORY_H
#define TODOFACTORY_H

#include "todoExec.h"
#include <memory>
class todoFactory{

    todoFactory()=default;
   public:
      static std::unique_ptr<todoFactory> create(){return std::move(std::unique_ptr<todoFactory>(new todoFactory));};

      //save
      static std::string save(std::unique_ptr<aTodo> &todoIn){
         std::string out;
         {  
            boost::iostreams::stream<boost::iostreams::back_insert_device<std::string>>os(out);
            boost::archive::text_oarchive archive(os);

            archive << todoIn;
         }  
         return out;

      }  

      static std::unique_ptr<aTodo> load(std::string const &s ){ 
         std::unique_ptr<aTodo> p; 
         {  
            boost::iostreams::stream<boost::iostreams::array_source> is(boost::iostreams::array_source{s.data(),s.size()});
            boost::archive::text_iarchive archive(is);
            archive >> p; 
         }  
         return std::move(p);
       }  
       std::unique_ptr<aTodo> createExec(std::string command) {return std::unique_ptr<aTodo>(new todoExec(command));};

};
#endif

client.cpp

#include <string>
#include <iostream>
#include "todoFactory.h"
BOOST_SERIALIZATION_ASSUME_ABSTRACT(aTodo)
BOOST_CLASS_EXPORT(todoExec)


#include <memory>

int main(void)
{
  char mtype=0x01;
   std::string dataToSend = "ls -al /home/ajonen";

   auto tmpTodoFactory=todoFactory::create(); //create factory
   auto anExecTodo=tmpTodoFactory->createExec(dataToSend); //create ExecTodo from factory
   std::string toSend= tmpTodoFactory->save(anExecTodo);
  return 0;
}

The error I get is:

terminate called after throwing an instance of 'boost::archive::archive_exception'
  what():  unregistered void cast 8todoExec<-5aTodo
Aborted

Answer 1

In class todoExec you've got a typo - is: serilize, should be: serialize; therefore the cast is not registered.