Re: [boost] Re: Re: [multi_index] announce: serialization support
----- Mensaje original ----- De: Robert Ramey <ramey@rrsd.com> Fecha: Miércoles, Diciembre 1, 2004 10:15 pm Asunto: [boost] Re: Re: [multi_index] announce: serialization support [snip]
If you guarentee that the container itself is always serialized before your indices, then de-serialization of the indices would automatically be reduced to providing the original (tracked) pointer. In such a case, I would think the whole isse would never appear and that the implementation would be very straight forward.
I think this is not correct (but I'd like to be proven wrong, that'd mean I could simplify my code.) Consider this: struct foo { std::list<std::string> cont; std::string* pos; // pos points to an element of cont private: friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int) { ar&cont; // before pos, as you suggest ar&pos; } }; My thesis is that loading a foo will get it wrong --pos won't be pointing to an element of cont, but rather to some random address in stack memory. I'll check it out on my compiler tomorrow, but I was already through this when designing multi_index serialization. See my point now? Am I missing something? Joaquín M López Muñoz Telefónica, Investigación y Desarrollo
"JOAQUIN LOPEZ MU?Z" <joaquin@tid.es> wrote in message news:206712203b1d.203b1d206712@tid.es...
----- Mensaje original ----- De: Robert Ramey <ramey@rrsd.com> Fecha: Miércoles, Diciembre 1, 2004 10:15 pm Asunto: [boost] Re: Re: [multi_index] announce: serialization support
[snip]
If you guarentee that the container itself is always serialized before your indices, then de-serialization of the indices would automatically be reduced to providing the original (tracked) pointer. In such a case, I would think the whole isse would never appear and that the implementation would be very straight forward.
I think this is not correct (but I'd like to be proven wrong, that'd mean I could simplify my code.) Consider this:
struct foo { std::list<std::string> cont; std::string* pos; // pos points to an element of cont
private: friend class boost::serialization::access;
template<class Archive> void serialize(Archive & ar, const unsigned int) { ar&cont; // before pos, as you suggest ar&pos; } };
My thesis is that loading a foo will get it wrong --pos won't be pointing to an element of cont, but rather to some random address in stack memory. I'll check it out on my compiler tomorrow, but I was already through this when designing multi_index serialization. See my point now? Am I missing something?
Hmmm - let me consider this. My view is based on the test test_list_ptr which serializes a list of pointers. In this case each list element is tracked because its a pointer. when a pointer is de-serialized a second time, tracking assures that the pointer is reloaded. In your case - std::string is tracked on output. When it its serialized a second time, only the object ID is written out. So when it is read back in the second time, the serialization system recognizes that its a copy and just reloads it. This only gotcha is that most primitive types are not tracked by default. and std::string has been assigned a serialization trait of "primitive" that means don't track. So I believe that this would work for non-primitive types. If you need this towork for a prmitive type (e.g. int, or...) use a serialization wrapper. Robert Ramey
participants (2)
-
JOAQUIN LOPEZ MU?Z -
Robert Ramey