Hi again, I have now tried to get your suggested solution to work, but did not succeed.

template<typename Archive> void serialize(Archive &ar, const unsigned int) {  auto * data_ptr = &data;  ar & data_ptr; // load and save through pointer

 if(Archive::is_loading::value) {    data = std::move(*data_ptr); // no-throw    ar.reset_object_address(&data, data_ptr);    delete data_ptr; // not sure here  }

This produced a compiler error, so I slitted it into separated load and save methods which looks like this: BOOST_SERIALIZATION_SPLIT_MEMBER(); template<class Archive> void save(Archive & ar, const unsigned int version) const { const std::vector<unsigned> * data_ptr = &data; ar & data_ptr; // load and save through pointer } template<class Archive> void load(Archive & ar, const unsigned int version) { const vector<int> * data_ptr; ar & data_ptr; // load and save through pointer data = std::move(*data_ptr); // no-throw ar.reset_object_address(&data, data_ptr); delete data_ptr; } But unfortunately, when I loads all the remaining pointers to data, the pointers has not been reset. This make me think the "ar.reset_object_address(&data, data_ptr);" method does not work properly ( I have ensured that it is executed before the loads ). Also, if I add: BOOST_STATIC_ASSERT( (boost::serialization::tracking_level< const std::vector<unsigned> * >::value != boost::serialization::track_never) ); I get an compiler error saying static assert failed. Why is that? shouldn't everything serialized through a pointer be tracked? What can I do to fix this? Best regards Allan W. Nielsen

Hi

This whole thing looks a little suspicious to me. Well, it is most likely because I;m doing it completely wrong ;) Please correct me.

I'd have to spend considerable time looking into it.  But I'm curious why you don't just do the following:

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

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

Because I have a shared pointer, and ( for other reasons ) I do not want to use "shared_ptr" So, a simplified version of my problem could look like this: struct A { std::vector<unsigned> data; }; struct B { const std::vector<unsigned> * data_ptr; }; struct C { A a; std::vector<B> elements; }; What would a serializing function for A, B and C look like. Best regards Allan W. Nielsen

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 Hi! Am 12.03.12 22:05, schrieb Robert Ramey:

template<class Archive> void serialize(Archive &ar, A & a, const unsigned int version){ ar & data;; }

When first serializing through a reference, how come that the vector instance is tracked? Is every object tracked by default? I do not understand the magic behind selective tracking. Frank -----BEGIN PGP SIGNATURE----- Version: GnuPG/MacGPG2 v2.0.17 (Darwin) Comment: GPGTools - http://gpgtools.org Comment: keyserver x-hkp://pool.sks-keyservers.net iEYEARECAAYFAk9e5PEACgkQhAOUmAZhnmqVgwCeKXKBt/yZN4OL1OlAT9mVHKIs Q4UAn0fhGf/whLhV2Ncwnlp4WZzQpAqb =3Eql -----END PGP SIGNATURE-----

Hi again, I have now created a small run able program which illustrates the problem I'm having: #include <assert.h> #include <vector> #include <sstream> #include <boost/archive/binary_oarchive.hpp> #include <boost/archive/binary_iarchive.hpp> #include <boost/serialization/vector.hpp> std::stringstream ss; // A wrapper class created to controle the serialization traits template< typename T > struct vector_wrapper { std::vector<T> v; template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & v; } }; namespace boost { namespace serialization { template<class T> struct tracking_level<const vector_wrapper<T> * > { typedef mpl::integral_c_tag tag; typedef mpl::int_<track_always> type; BOOST_STATIC_CONSTANT( int, value = tracking_level::type::value ); }; } // namespace serialization } // namespace boost struct A { vector_wrapper<unsigned> data; BOOST_SERIALIZATION_SPLIT_MEMBER(); A() {}; A(unsigned i) { data.v.push_back(i); } template<class Archive> void save(Archive & ar, const unsigned int version) const { const vector_wrapper<unsigned> * ptr = &data; ar & ptr; std::cout << "SAVE> data size: " << data.v.size() << " ptr: " << &data << std::endl; } template<class Archive> void load(Archive & ar, const unsigned int version) { const vector_wrapper<unsigned> * ptr = 0; ar & ptr; data = *ptr; ar.reset_object_address(&data, ptr); // does not seem to have any effect std::cout << "LOAD> data size: " << data.v.size() << " ptr: " << &data << std::endl; delete ptr; } }; struct B { const vector_wrapper<unsigned> * ptr_data; B() : ptr_data(0) { } B( const vector_wrapper<unsigned> * p ) : ptr_data(p) { } template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & ptr_data; std::cout << "SERILIAZE> ptr: " << ptr_data << std::endl; } }; struct C { A a; B b1; B b2; B b3; C () { } // default constructor C (unsigned i) : // bootstrap constructor a(i), b1(&a.data), b2(&a.data), b3(&a.data) { } template<class Archive> void serialize(Archive & ar, const unsigned int version) { ar & a; ar & b1; ar & b2; ar & b3; } }; int main(int argc, const char *argv[]) { C c1(7); boost::archive::binary_oarchive o(ss); o << c1; C c2; boost::archive::binary_iarchive i(ss); i >> c2; assert( &c1.a.data == c1.b1.ptr_data ); assert( &c1.a.data == c1.b2.ptr_data ); assert( &c1.a.data == c1.b3.ptr_data ); assert( &c2.a.data == c2.b1.ptr_data ); // fails assert( &c2.a.data == c2.b2.ptr_data ); // fails assert( &c2.a.data == c2.b3.ptr_data ); // fails return 0; } I know that this will work fine, if I used a shared_ptr to manage the data pointers, but I can not use a shared_ptr in the target application. Any hints on how to fix this would be most appreciated. Best regards Allan W. Nielsen

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 Hi! Am 13.03.12 20:39, schrieb Robert Ramey:

I posted a example - did this not work?

It worked for me using Boost 1.47. The code below can output or input serialization data. It links to Boost.Serialization of course. I tested it by running it twice and piping the output of the first into the input of the second instance: $dist/test 1 | dist/test 2 1 Frank ///// Main.cpp: #include <vector> struct A { std::vector<unsigned> data; }; struct B { const std::vector<unsigned> * data_ptr; }; struct C { A a; std::vector<B> elements; }; template<class Archive> void serialize(Archive &ar, A & a, const unsigned int version){ ar & a.data; } template<class Archive> void serialize(Archive &ar, B & b, const unsigned int version){ ar & b.data_ptr; } template<class Archive> void serialize(Archive &ar, C & c, const unsigned int version){ ar & c.a; ar & c.elements; } struct Sample { Sample(); C const& getC() { return c; } C c; } sample; Sample::Sample() { c.a.data.push_back(5); const B b = { &c.a.data }; c.elements.resize(2, b); } #include <boost/archive/text_oarchive.hpp> #include <boost/archive/text_iarchive.hpp> #include <boost/serialization/vector.hpp> #include <boost/lexical_cast.hpp> #include <iostream> #include <ostream> void output() { boost::archive::text_oarchive ar(std::cout); ar << sample.c; } void input() { boost::archive::text_iarchive ar(std::cin); ar >> sample.c; std::cout << (!sample.c.elements.empty() && &sample.c.a.data == sample.c.elements.front().data_ptr) << std::endl; } int main(int argc, char *argv[]) { if(argc < 2) { std::cerr << "no argument\n"; return -3; } switch (boost::lexical_cast<unsigned>(argv[1])) { case 1: output(); break; case 2: input(); break; default: std::clog << "give option 1 or 2\n"; return -2; } } -----BEGIN PGP SIGNATURE----- Version: GnuPG/MacGPG2 v2.0.17 (Darwin) Comment: GPGTools - http://gpgtools.org Comment: keyserver x-hkp://pool.sks-keyservers.net iEYEARECAAYFAk9flVAACgkQhAOUmAZhnmr53QCeNFO8S6Ph3ps9ZXemwoJsD5x/ jYwAn1/S+bKwVAXkHdYrti8LKBhtzLvc =x19a -----END PGP SIGNATURE-----

Allan Nielsen wrote:

Hi Robert

...

I posted a example - did this not work?

I did look at you example, but I did not understand how it could possibly work. And therefor for I did not try it out as the first thing.

However, I have tried it now, and it is working. The only problem is that I do not understand how.

Basically, if a) you've installed boost b) read the documentation for the serialization library c) and it's not clear why my code works then It's a bug in the documentation. As far as I'm concerned this is the same as a bug in the code they really are "one thing". So, if you go back the documentation, I believe you should be able to discover why my example works. If you do this and conclude that something needs to be added to the documentation feel free to propose some more language the documentation which would avoided the confusion. Then post this is a trac item and it will eventually make it's way into the official documentation. This will give you a constructive way to vent your frustration and avoid having another person suffer this same fate.

Also, I do not understand why the (not so elegant) example of mine, does not work...

Honestly, I couldn't really understand your example without investing a lot more effort. But if you do the above, you will likely be able to understand this yourself.

But anyway, thanks for providing a good solution to my problem.

My pleasure Robert Ramey