diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/stdapis/boost/serialization/base_object.hpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/epoc32/include/stdapis/boost/serialization/base_object.hpp	Tue Mar 16 16:12:26 2010 +0000
@@ -0,0 +1,172 @@
+#ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP
+#define BOOST_SERIALIZATION_BASE_OBJECT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// base_object.hpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+// if no archive headers have been included this is a no op
+// this is to permit BOOST_EXPORT etc to be included in a 
+// file declaration header
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/void_cast_fwd.hpp>
+
+namespace boost {
+namespace serialization {
+
+namespace detail {
+    // metrowerks CodeWarrior
+    #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) 
+        // only register void casts if the types are polymorphic
+        template<class Base, class Derived>
+        struct base_register{
+            struct nothing {
+                static const void_cast_detail::void_caster & invoke(){
+                    return static_cast<const void_cast_detail::void_caster &>(
+                        * static_cast<const void_cast_detail::void_caster *>(NULL)
+                    );
+                }
+            };
+
+            // hold a reference to the void_cast_register and void_caster in the hope of 
+            // ensuring code instantiation for some compilers with over-zealous link time 
+            // optimiser. The compiler that demanded this was CW
+            struct reg{
+                typedef const void_cast_detail::void_caster & (* t_vcr)(
+                    const Derived *,
+                    const Base *
+                );
+                t_vcr m_vcr;
+                static const void_cast_detail::void_caster & invoke(){
+                    return  void_cast_register<const Derived, const Base>(
+                        static_cast<const Derived *>(NULL),
+                        static_cast<const Base *>(NULL)
+                    );
+                }
+                reg() :
+                    m_vcr(static_cast<t_vcr>(void_cast_register))
+                {
+                }
+            } m_reg;
+
+            static const void_cast_detail::void_caster & invoke(){
+                typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                    BOOST_DEDUCED_TYPENAME type_info_implementation<Base>::type::is_polymorphic,
+                    mpl::identity<reg>,
+                    mpl::identity<nothing>
+                >::type typex;
+                return typex::invoke();
+            }
+
+            const void_cast_detail::void_caster & m_vc;
+            Derived & m_d;
+
+            base_register(Derived & d) :
+                m_vc(invoke()),
+                m_d(d)
+            {}
+            Base & get_base() const {
+                return m_d;
+            }
+        };
+    #else
+        // only register void casts if the types are polymorphic
+        template<class Base, class Derived>
+        struct base_register{
+            struct nothing {
+                static void invoke(){}
+            };
+            struct reg{
+                static void invoke(){
+                    void_cast_register<const Derived, const Base>(
+                        static_cast<const Derived *>(NULL),
+                        static_cast<const Base *>(NULL)
+                    );
+                }
+            };
+            static void invoke(){
+                typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+                    BOOST_DEDUCED_TYPENAME type_info_implementation<Base>::type::is_polymorphic,
+                    mpl::identity<reg>,
+                    mpl::identity<nothing>
+                >::type typex;
+                typex::invoke();
+            }
+        };
+    #endif
+    // get the base type for a given derived type
+    // preserving the const-ness
+    template<class B, class D>
+    struct base_cast
+    {
+        typedef BOOST_DEDUCED_TYPENAME
+            mpl::if_<
+                is_const<D>,
+                const B,
+                B
+        >::type type;
+        BOOST_STATIC_ASSERT(is_const<type>::value == is_const<D>::value);
+    };
+} // namespace detail
+
+// metrowerks CodeWarrior
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) 
+template<class Base, class Derived>
+BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type & 
+base_object(Derived &d)
+{
+    BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
+    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
+    typedef BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type type;
+    return detail::base_register<type, Derived>(d).get_base();
+}
+// BORLAND
+#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+template<class Base, class Derived>
+const Base & 
+base_object(const Derived & d)
+{
+    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
+    detail::base_register<Base, Derived>::invoke();
+    return static_cast<const Base &>(d);
+}
+#else
+template<class Base, class Derived>
+BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type & 
+base_object(Derived &d)
+{
+    BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
+    BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
+    typedef BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type type;
+    detail::base_register<type, Derived>::invoke();
+    return static_cast<type &>(d);
+}
+#endif
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP