diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/stdapis/boost/serialization/void_cast.hpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/epoc32/include/stdapis/boost/serialization/void_cast.hpp	Tue Mar 16 16:12:26 2010 +0000
@@ -0,0 +1,200 @@
+#ifndef  BOOST_SERIALIZATION_VOID_CAST_HPP
+#define BOOST_SERIALIZATION_VOID_CAST_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
+// void_cast.hpp:   interface for run-time casting of void pointers.
+
+// (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)
+// gennadiy.rozental@tfn.com
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/smart_cast.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/serialization/config.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+namespace boost { 
+namespace serialization { 
+
+class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info;
+
+// Given a void *, assume that it really points to an instance of one type
+// and alter it so that it would point to an instance of a related type.
+// Return the altered pointer. If there exists no sequence of casts that
+// can transform from_type to to_type, return a NULL.  
+
+BOOST_SERIALIZATION_DECL(void const *)
+void_upcast(
+    extended_type_info const & derived_type,  
+    extended_type_info const & base_type, 
+    void const * const t,
+    bool top = true
+);
+
+inline void *
+void_upcast(
+    extended_type_info const & derived_type_,
+    extended_type_info const & base_type_,
+    void * const t 
+){
+    return const_cast<void*>(void_upcast(
+        derived_type_, 
+        base_type_, 
+        const_cast<void const *>(t)
+    ));
+}
+
+BOOST_SERIALIZATION_DECL(void const *)
+void_downcast(
+    extended_type_info const & derived_type,  
+    extended_type_info const & base_type, 
+    void const * const t,
+    bool top = true
+);
+
+inline void *
+void_downcast(
+    extended_type_info const & derived_type_,
+    extended_type_info const & base_type_,
+    void * const t 
+){
+    return const_cast<void*>(void_downcast(
+        derived_type_, 
+        base_type_, 
+        const_cast<void const *>(t)
+    ));
+}
+
+namespace void_cast_detail {
+
+// note: can't be abstract because an instance is used as a search argument
+class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) void_caster
+{
+    friend struct void_caster_compare ;
+    friend 
+    BOOST_SERIALIZATION_DECL(void const *)  
+    boost::serialization::void_upcast(
+        const extended_type_info & derived_type,
+        const extended_type_info & base_type,
+        const void * t,
+        bool top
+    );
+    friend 
+    BOOST_SERIALIZATION_DECL(void const *)  
+    boost::serialization::void_downcast(
+        const extended_type_info & derived_type,
+        const extended_type_info & base_type,
+        const void * t,
+        bool top
+    );
+    // each derived class must re-implement these;
+    virtual void const * upcast(void const * t) const = 0;
+    virtual void const * downcast(void const * t) const = 0;
+    // Data members
+    extended_type_info const & m_derived_type;
+    extended_type_info const & m_base_type;
+protected:
+    static void static_register(const void_caster *);
+public:
+    // Constructor
+    void_caster(
+        extended_type_info const & derived_type_,
+        extended_type_info const & base_type_ 
+    );
+    // predicate used to determine if this void caster includes
+    // a particular eti *
+    bool includes(const extended_type_info * eti) const;
+    virtual ~void_caster();
+private:
+    // cw 8.3 requires this!!
+    void_caster& operator=(void_caster const&);
+};
+
+template <class Derived, class Base>
+class void_caster_primitive : 
+    public void_caster
+{
+    virtual void const* downcast( void const * t ) const {
+        Derived * d = boost::smart_cast<const Derived *, const Base *>(
+            static_cast<const Base *>(t)
+        );
+        return d;
+    }
+    virtual void const* upcast(void const * t) const {
+        Base * b = boost::smart_cast<const Base *, const Derived *>(
+            static_cast<const Derived *>(t)
+        );
+        return b;
+    }
+
+public:
+    static const void_caster_primitive instance;
+    void_caster_primitive() BOOST_USED;
+};
+
+template <class Derived, class Base>
+void_caster_primitive<Derived, Base>::void_caster_primitive() :
+    void_caster( 
+        * type_info_implementation<Derived>::type::get_instance(), 
+        * type_info_implementation<Base>::type::get_instance() 
+    )
+{
+    this->static_register(& instance);
+}
+
+// the purpose of this class is to create to->from and from->to instances
+// of void_caster_primitive for each related pair of types.  This has to be
+// done a pre-execution time - hence the usage of static variable.
+template<class Derived, class Base>
+const void_caster_primitive<Derived, Base>
+    void_caster_primitive<Derived, Base>::instance;
+
+} // void_cast_detail 
+
+// Register a base/derived pair.  This indicates that it is possible
+// to upcast a void pointer from Derived to Base and downcast a
+// void pointer from Base to Derived.  Note bogus arguments to workaround
+// bug in msvc 6.0
+template<class Derived, class Base>
+BOOST_DLLEXPORT 
+inline const void_cast_detail::void_caster & void_cast_register(
+    const Derived * dnull, 
+    const Base * bnull
+) BOOST_USED;
+template<class Derived, class Base>
+BOOST_DLLEXPORT 
+inline const void_cast_detail::void_caster & void_cast_register(
+    const Derived * /* dnull = NULL */, 
+    const Base * /* bnull = NULL */
+){
+    return void_cast_detail::void_caster_primitive<
+        const Derived, 
+        const Base
+    >::instance;
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_VOID_CAST_HPP