ich spiele gerade ein bisschen mit boost serialization. Recht beeindruckend wie schoen einfach und durchdacht alles funktioniert, ABER es scheint das man sich im code vorher entscheiden muss ob man XML oder stream serialisieren will. Ich vermute mal der Hintergrund ist weil man die Symetrie zwischen Serialisierung/Deserialisierung erhalten will, sprich etwas was ich als stream Serialisiert habe kann ich ja nicht als XML Deserialisieren. Demzufolge hat ja boost die speziellen mechanismen fuer XML:

boost::serialization::make_nvp
BOOST_SERIALIZATION_NVP

dieser Anatz fuehrt aber dazu das man fuer XML und stream Serialisierung verschiedene code braucht:

template<class Archive>
void serializeXML(Archive & ar, const unsigned int version)
{
  ar & BOOST_SERIALIZATION_NVP( m_iJobID );
}

template<class Archive>
void serializeStream(Archive & ar, const unsigned int version)
{
  ar & m_iJobID;
}

mein naiver ansatz waere einfach eine Spezialialisierung:

template<typename TSerializer>
struct SerializeWrapper
{
	template<typename TValue>
	static TValue& wrap( const char*, TValue& value_r ){ return value_r; }
};

template<>
struct SerializeWrapper<boost::archive::xml_oarchive>
{
	template<typename TValue>
	static const boost::serialization::nvp<TValue> wrap( const char*pStrName_r, TValue& value_r ){ return boost::serialization::make_nvp(pStrName_r, value_r); }
};

#define BUILD_SERIALIZE_PARAM(param, archive) SerializeWrapper<archive>::wrap( BOOST_PP_STRINGIZE(param), param )

was obigen code fuer XML und Stream zu

template<class Archive>
void serialize(Archive & ar, const unsigned int version)
{
		ar & BUILD_SERIALIZE_PARAM( m_JobState, Archive );
}

vereinheitlicht. Sicher geht das schoener und es wundert mich das es dafuer nichts in der boost library zu geben scheint...

Danke und Viele Gruesse,
Tobias

dieser Anatz fuehrt aber dazu das man fuer XML und stream Serialisierung verschiedene code braucht:

... und das Problem ist welches genau?

namespace SerializeWrapper
{
	template<typename TSerializer, typename TValue>
	void wrappedSerialize( const char*, TSerializer& ar, TValue& value_r )
	{ 
		ar << value_r;
	}

	template<typename TValue>
	void wrappedSerialize( const char*pStrName_r, boost::archive::xml_oarchive& ar, TValue& value_r )
	{
		ar & boost::serialization::make_nvp(pStrName_r, value_r);
	}
}

#define SERIALIZE_PARAM(param, archive) SerializeWrapper::wrappedSerialize( BOOST_PP_STRINGIZE(param), archive, param )

womit die Serialisierung immer zu:

SERIALIZE_PARAM( job, arOut );

wird. Leider klebt man immer an Macros wenn man den XML node name automatisch aus dem Variablennamen generieren will.
Zumindest ist man so weitestgehend archiv-typ unabhaengig (text, oder XML)