Re: [Boost-users] [serialization] can I serialize concrete types that are not acessible where the archive is created

29 Sep 2010

      ADDENDUM (NB I'm using release boost 1.44 with Visual C++ 2008 SP1 with the latest patches)

test_dll_plugin in the serialization test suite seems to suffer from the
same problem I'm having

I've created two standard empty win32 console projects in Visual Studio:
* one to build a DLL with polymorphic_base.cpp and polymorphic_derived2.cpp
* one to build an EXE client for the above DLL containing only test_dll_plugin.cpp

The assert at line 82 of test_dll_plugin.cpp fails at runtime, showing the EXE
does not have registered ETI for the polymorphic_derived2 type linked into the DLL.

What could be the problem here?

-----Original Message-----
From: Massaro Alessio 
Sent: 29 September 2010 18:06
To: boost-users@lists.boost.org
Subject: RE: [Boost-users] [serialization] can I serialize concrete types that are not acessible where the archive is created

Thanks for the pointer Robert

I trawled up the following 2 items of doc, but made little process
http://www.boost.org/doc/libs/1_44_0/libs/serialization/doc/special.html#dll...
http://www.boost.org/doc/libs/1_44_0/libs/serialization/doc/special.html#plu...

If I follow the documentation I get a "derived class not registered..." at
runtime. So I looked at the unit tests.

The one for my case seems to be test_dll_plugin.cpp.

In that test polymorphic_base (the interface type known statically at the poiont
of serialization) uses the extended_type_info_no_rtti ETI scheme.

This is in contrast to polymorphic_derived2 (the concrete type UNknown statically at
the poiont of serialization) using the extended_type_info_typeid ETI scheme.

Do I *have to* use no_rtti for my abstract interface types?

If I use the typeid scheme everything builds but I get "derived class not registered..."
at runtime.

If I follow the test_dll_plugin.cpp pattern, then the code STATIC_ASSERTS
extended_type_info_no_rtti.hpp(87) at the point of serialization.

The STATIC_ASSERT comment says
            // if your program traps here - you failed to 
            // export a guid for this type.  the no_rtti
            // system requires export for types serialized
            // as pointers.

Adding
BOOST_CLASS_EXPORT_KEY(boost::shared_ptr<I_DoSomething>)
or
BOOST_CLASS_EXPORT_GUID(boost::shared_ptr<I_DoSomething>, "xyz")
to serialize.cpp will make no difference.

I really can't figure out what's wrong. I hope someone out there can spot
the problem!

##################### DLL/MODULE 1 #####################################

-------------------------------------------- interface.hpp

#include <boost/shared_ptr.hpp>

struct DLL_EXPORT I_DoSomething
{
	virtual const char * get_key() const = 0;
	virtual void doIt() = 0;
	static boost::shared_ptr<I_DoSomething> create(); // static factory

private:
	friend class boost::serialization::access;
	template<class Archive>
	void serialize(Archive & /* ar */, const unsigned int /* file_version */);
}

#include <boost/serialization/assume_abstract.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/type_info_implementation.hpp>
#include <boost/serialization/extended_type_info_no_rtti.hpp>

BOOST_SERIALIZATION_ASSUME_ABSTRACT(I_DoSomething)
BOOST_CLASS_EXPORT_KEY(I_DoSomething)
BOOST_CLASS_TYPE_INFO(I_DoSomething, boost::serialization::extended_type_info_no_rtti<I_DoSomething>)

-------------------------------------------- ConcreteType.cpp

#include "interface.hpp"

class ConcreteType : public I_DoSomething
{
	virtual const char * get_key() const
	{
		return "ConcreteType";
	}
	...
	.....
private:
	void serialize(Archive & ar, const unsigned int /*version*/)
	{
		ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(I_DoSomething);
		ar & ...
	} 
}

boost::shared_ptr<I_DoSomething> I_DoSomething::create()
{
	return new ConcreteType();
}

#include <boost/serialization/export.hpp>
#include <boost/serialization/extended_type_info_typeid.hpp>

BOOST_CLASS_EXPORT_KEY(ConcreteType)
BOOST_CLASS_TYPE_INFO(ConcreteType, boost::serialization::extended_type_info_typeid<ConcreteType>)
BOOST_CLASS_EXPORT_IMPLEMENT(ConcreteType)

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>

template DLLEXPORT void ConcreteType::serialize(boost::archive::xml_oarchive & ar, const unsigned int version);
template DLLEXPORT void ConcreteType::serialize(boost::archive::xml_iarchive & ar, const unsigned int version);

#include <boost/serialization/factory.hpp>
BOOST_SERIALIZATION_FACTORY_0(ConcreteType)

##################### DLL 2 which linked with DLL 1 #####################

-------------------------------------------- serialize.cpp

#include "interface.hpp"
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/shared_ptr.hpp>

BOOST_CLASS_EXPORT_KEY(boost::shared_ptr<I_DoSomething>)

...
boost::shared_ptr<I_DoSomething> obj = I_DoSomething::create();
boost::text_oarchive oa;
oa << obj; // <-------- STATIC_ASSERTS at extended_type_info_no_rtti.hpp(87)
...