Hi Robert, Thanks for posting your proposal! There is a close similarity between your proposal and Dave's. Dave's classes array::oarchive and array::iarchive are archive adaptors, just like the one you are proposing. We all understand what you mean by archive adaptor. If you take a look a closer look at Dave's proposal then you will surely see that he built on your idea of using archive adaptors. Aside from naming differences, and other minor things the main difference between your proposal and Dave's is the choice of customization point used by the authors of serialization functions for new array-like classes (such as e.g. std::valarray). How can they profit from the optimized saving of contiguous arrays of some data types? In your proposal these authors should provide an overload of template<class Base, class T> void override(boost::archive::bitwise_oarchive_adaptor<Base> &, T const &) In this function they have to re-implement the serialization of the specific class. Dave on the other hand proposes that these authors call a function save_array, which by default will just do a simple loop (as in the current library), but dispatch to an optimized function when available. Let me state clearly that both these approaches can coexist and there is no conflict. Dave's proposal uses a wrapper just as the one you use to override the default serialization provided by your library, but in addition provides a save_array and load_array function that can be used with any archive (and without modifications to your library). Let me take std::valarray as an example of what would have to be implemented by the author of std::valarray serialization. In your scheme that would be: ---------------------------------------------------- // the default serialize function template<class Base, class T> void save( boost::archive::bitwise_oarchive_adaptor<Base> &ar, const std::valarray<T> & t, ){ const unsigned int count = t.size(); ar << count; for (unsigned int i=0; i<t.size();++i) ar << make_nvp("item",t[i]); } // the optimized overload of the override function template<class Base, class T> void override( boost::archive::bitwise_oarchive_adaptor<Base> &ar, const std::valarray<T> & t, boost::mpl::true_ ){ const unsigned int count = t.size(); ar << count; ar.save_binary(t.size() * sizeof(T), get_data(t)); } // the dispatch either to the optimized or the default version of override template<class Base, class T, int N> void override( boost::archive::bitwise_oarchive_adaptor<Base> &ar, const std::vector<T> & t ){ override(ar, t, boost::serialization::is_bitwise_serializable<T>::type()); } ---------------------------------------------------- Contrast this with Dave's proposal, where one a *single* function needs to be written to have both unoptimized and optimized serialization. ---------------------------------------------------- template<class Base, class T> void save(boost::archive::bitwise_oarchive_adaptor<Base> &ar, const std::valarray<T> & t,) { const unsigned int count = t.size(); ar << count; save_array(ar, get_data(t),t.size()); } ---------------------------------------------------- Not only is this much shorter, it is even simpler and less error- prone and easier to maintain than the default serialization function in your suggestion, since the for-loop over the elements of the std::valarray is omitted. And please keep in mind that if the archive does not provide an optimized version of save_array, the code that is executed will be *exactly* the for-loop in the other example. The simplicity of Dave's proposal is no chance. I know that he spent many hours thinking about the problem to come up with an elegant and simple solution. Let me stress again that both options can coexist, i.e. we can write an array_adaptor that provides both your override() mechanism and a save_array() function. There is no conflict at all between the two proposals. It will then be up to the authors of the serialization function of a new class to choose which mechanism they prefer. For me the choice is obvious, but your mileage may vary. Matthias