Zitat von Robert Ramey :

For now I would suggest

d) Make your own stream buffer implementation which sends the raw data down the pipe.

you might find some inspiration for this here: https://svn.boost.org/svn/boost/sandbox/transaction/boost/transact/archive.h... https://svn.boost.org/svn/boost/sandbox/transaction/boost/transact/char_arch... it isn't a streambuf implementation but a Boost.Serialization archive that can write to any output iterator with a "char" valuetype. e.g. serialization_oarchive< char_oarchive< std::back_insert_iterator< std::vector<char> >

by writing an output iterator to a fixed-size network buffer you should be able to efficiently send your network message in chunks.

Daniel Herb wrote:

Thanks for the answers! I've tested some other cases based on your suggestions and now have the following situation: - I create package classes which are derived from base classes, these will hold non-pointer objects - The packages split the objects into categories - On the lowest level I have a list of shared_ptr<Package> - That way I still have some kind of dynamic without wasting to much performance

I guess that's at least somehow what Robert suggested. The problem I have with this is the following: My application uses shared_ptr to hold most of the data. So if i want to create a package I would have to copy the data first before I can put it into the container within the package. Am I right or have I missed some part of the idea?

I think you've got it. As you can see, it's basically a way to use the right subset of serialization functionality. To refine the idea, I thought about this a tiny bit more and here would be another thing to try. I don't remember if its the same as I suggested before struct my_data { ... shared_ptr<T1> m_t1; ... template<class Archive> void serialization(... // the normal way }; // this makes sure that new values are resent each time BOOST_SERIALIZATION_TRACKING(T1, no_tracking) ... struct my_tranmission_wrapper { // don't put any pointers here !!! const T1 & m_t1; ... my_transmission_wrapper(my_data &d) : m_t1(d.m_t1), ... {} } sender binary_ostream_buf bs; // created connection to other machine binary_oarchive boa(bs) my_transmission_wrapper tw(d); my_data d; boa << d; // first transmission creates all the shared pointers at the other end of the system loop{ // update d with new values even though archive is not re-created boa << tw(d); // serialize again with the new values } } reciever binary_istream_buf bs; // created connection to other machine binary_iarchive bia(bs); my_data d; bia >> d; // first transmission creates all the shared pointers at the other end of the system my_transmission_wrapper tw(d); loop{ bia >> tw(d); // serialize again with the new values // update d with new values even though archive is not re-created // d has new values do_work(&d); } Good luck with this Robert Ramey