On Thu, Sep 16, 2010 at 2:43 PM, Anonymous user wrote:

Hello everybody,

I'm currently trying to serialize functors.

Apparently, it is not possible to serialize boost::function objects,

is it possible to find a way to serialize pointer to function ? (in order to make working the example below*)

If it is definitively not possible, is there a way to 'register' a relation betwwen objects and functor ? (using MPL library).

The idea is to rebuild the boost function according to the 'Object and 'Type' class of the template'.

Example:

mpl::pair container;

serialize()

{

boost::function m_getter=mpl::at< container,Object>;

}

*Here is the problem that  I'm trying to resolve:

MyObject myObject("before");

SetCommandstd::string,MyObject SetCommand(myObject,&MyObject::setName,&MyObject::getName,"after");

SetCommand.do();   // call functor 'MyObject::setName("after")'

SetCommand.undo(); // call functor 'MyObject::setName("before")'

template

class SetCommand : public Command

{

  public:

        template

        SetCommand(Object& o, const Setter& setter, const Getter& getter, const Type& value) :

            Command(),

            m_getter(boost::bind(getter, &o)),

    m_setter(boost::bind(setter, &o, _1)),

            initialValue(m_getter()),

            finalValue(value)

        {

        }

virtual void undo()

        {

            m_setter(initialValue) ;

        }

        virtual void do()

        {

            m_setter(finalValue) ;

        }

   private:

friend class boost::serialization::access;

SetCommand(){}

template <class Archive>

void serialize( Archive & ar, const unsigned int version )

{

  ar & m_getter; ERROR -> does not compile !!!

  ar & m_setter; ERROR -> does not compile !!!

  ar & initialValue;

  ar & finalValue;

}

boost::function m_getter ;

        boost::function m_setter ;

        Type initialValue ;

        Type finalValue ;

};

Thanks in advance.

You need to somehow register the function in there, if you know what a limited set of types it might be, an integer that can rebuild it would work, but the most common way is to just make a base class with an operator() and have a (shared) pointer to that be your 'function', then base classes (that can be properly serialized) to act as the functions. Not pretty, not the easiest, but it works well and is expandable.