diff -r 000000000000 -r bde4ae8d615e os/ossrv/stdcpp/tsrc/Boost_test/ptr_container/src/serialization.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/ossrv/stdcpp/tsrc/Boost_test/ptr_container/src/serialization.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,229 @@
+//
+// Boost.Pointer Container
+//
+//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/ptr_container/
+//
+
+#include <boost/test/unit_test.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/ptr_container/ptr_vector.hpp>
+#include <boost/ptr_container/ptr_deque.hpp>
+#include <boost/ptr_container/ptr_list.hpp>
+#include <boost/ptr_container/ptr_array.hpp>
+#include <boost/ptr_container/ptr_set.hpp>
+#include <boost/ptr_container/ptr_map.hpp>
+#include <boost/serialization/export.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/string.hpp>
+#include <fstream>
+#include <string>
+
+//
+// serialization helper: we can't save a non-const object
+// 
+template< class T >
+inline T const& as_const( T const& r )
+{
+    return r;
+}
+
+//
+// class hierarchy
+// 
+struct Base
+{
+    friend class boost::serialization::access;
+
+    int i;
+
+    
+    template< class Archive >
+    void serialize( Archive& ar, const unsigned int version )
+    {
+        ar & i;
+    }
+
+    Base() : i(42)
+    { }
+    
+    Base( int i ) : i(i)
+    { }
+    
+    virtual ~Base()
+    { }
+};
+
+inline bool operator<( const Base& l, const Base& r )
+{
+    return l.i < r.i;
+}
+
+struct Derived : Base
+{
+    int i2;
+
+    template< class Archive >
+    void serialize( Archive& ar, const unsigned int version )
+    {
+        ar & boost::serialization::base_object<Base>( *this );
+        ar & i2;
+    }
+
+    Derived() : Base(42), i2(42)
+    { }
+    
+    explicit Derived( int i2 ) : Base(0), i2(i2)
+    { }
+};
+
+BOOST_CLASS_EXPORT_GUID( Derived, "Derived" )
+
+//
+// test of containers
+// 
+// 
+
+template< class C, class T >
+void add( C& c, T* r, unsigned n )
+{
+    c.insert( c.end(), r ); 
+}
+
+template< class U, class T >
+void add( boost::ptr_array<U,2>& c, T* r, unsigned n )
+{
+    c.replace( n, r );
+}
+
+template< class Cont >
+void test_serialization_helper()
+{
+    Cont vec;
+    add( vec, new Base( -1 ), 0u );
+    add( vec, new Derived( 1 ), 1u );
+
+    std::ofstream ofs("filename");
+    boost::archive::text_oarchive oa(ofs);
+    oa << as_const(vec);
+    ofs.close();
+
+    
+    
+    std::ifstream ifs("filename", std::ios::binary);
+    boost::archive::text_iarchive ia(ifs);
+    Cont vec2;
+    ia >> vec2;
+    ifs.close();
+
+    BOOST_CHECK_EQUAL( vec.size(), vec2.size() );
+    BOOST_CHECK_EQUAL( (*vec2.begin()).i, -1 );
+    BOOST_CHECK_EQUAL( (*--vec2.end()).i, 0 );
+    typename Cont::iterator i = vec2.end();
+    --i;
+    Derived* d = dynamic_cast<Derived*>( &*i ); 
+    BOOST_CHECK_EQUAL( d->i2, 1 );
+}
+
+template< class Map >
+void test_serialization_map_helper()
+{
+    Map m;
+    std::string key1("key1"), key2("key2");
+    m.insert( key1, new Base( -1 ) );
+    m.insert( key2, new Derived( 1 ) );
+    BOOST_CHECK_EQUAL( m.size(), 2u );
+
+    std::ofstream ofs("filename");
+    boost::archive::text_oarchive oa(ofs);
+    oa << as_const(m);
+    ofs.close();
+
+
+    
+    std::ifstream ifs("filename", std::ios::binary);
+    boost::archive::text_iarchive ia(ifs);
+    Map m2;
+    ia >> m2;
+    ifs.close();
+
+    BOOST_CHECK_EQUAL( m.size(), m2.size() );
+    BOOST_CHECK_EQUAL( m2.find(key1)->second->i, -1 );
+    BOOST_CHECK_EQUAL( m2.find(key2)->second->i, 0 );
+    typename Map::iterator i = m2.find(key2);
+    Derived* d = dynamic_cast<Derived*>( i->second ); 
+    BOOST_CHECK_EQUAL( d->i2, 1 );
+    
+}
+
+//
+// basic test of hierarchy
+// 
+void test_hierarchy()
+{
+    Base* p = new Derived();
+    std::ofstream ofs("filename");
+    boost::archive::text_oarchive oa(ofs);
+    oa << as_const(p);
+    ofs.close();
+
+    
+    Base* d = 0; 
+    std::ifstream ifs("filename", std::ios::binary);
+    boost::archive::text_iarchive ia(ifs);
+    ia >> d;
+    ifs.close();
+    
+    BOOST_CHECK_EQUAL( p->i, d->i );
+    BOOST_CHECK( p != d );
+    BOOST_CHECK( dynamic_cast<Derived*>( d ) );
+    delete p;
+    delete d;
+} 
+
+//
+// test initializer
+// 
+void test_serialization()
+{
+    test_hierarchy();
+    test_serialization_helper< boost::ptr_deque<Base> >();
+    test_serialization_helper< boost::ptr_list<Base> >();
+    test_serialization_helper< boost::ptr_vector<Base> >();
+    test_serialization_helper< boost::ptr_array<Base,2> >();
+  
+    test_serialization_helper< boost::ptr_set<Base> >();
+    test_serialization_helper< boost::ptr_multiset<Base> >();
+
+    test_serialization_map_helper< boost::ptr_map<std::string,Base> >();
+
+//
+// GCC hangs when calling find() on a multimap!
+//      
+//#if !BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0300))
+
+    test_serialization_map_helper< boost::ptr_multimap<std::string,Base> >();
+    
+//#endif
+
+}
+
+
+using boost::unit_test::test_suite;
+
+test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    test_suite* test = BOOST_TEST_SUITE( "Pointer Container Test Suite" );
+
+    test->add( BOOST_TEST_CASE( &test_serialization ) );
+
+    return test;
+}
+
+