diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/stdapis/boost/ptr_container/ptr_array.hpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/epoc32/include/stdapis/boost/ptr_container/ptr_array.hpp	Tue Mar 16 16:12:26 2010 +0000
@@ -0,0 +1,239 @@
+//
+// 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/
+//
+
+#ifndef BOOST_PTR_CONTAINER_PTR_ARRAY_HPP
+#define BOOST_PTR_CONTAINER_PTR_ARRAY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/array.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/ptr_container/ptr_sequence_adapter.hpp>
+
+namespace boost
+{
+
+    namespace ptr_container_detail
+    {
+        template
+        <
+            class T,
+            size_t N,
+            class Allocator = int // dummy
+        >
+        class ptr_array_impl : public boost::array<T,N>
+        {
+        public:
+            typedef Allocator allocator_type;
+
+            ptr_array_impl( Allocator a = Allocator() )
+            {
+                this->assign( 0 );
+            }
+
+            ptr_array_impl( size_t, T*, Allocator a = Allocator() )
+            {
+                this->assign( 0 );
+            }
+        };
+    }
+
+    template
+    <
+        class T,
+        size_t N,
+        class CloneAllocator = heap_clone_allocator
+    >
+    class ptr_array : public
+        ptr_sequence_adapter< T,
+                              ptr_container_detail::ptr_array_impl<void*,N>,
+                              CloneAllocator >
+    {
+    private:
+        typedef ptr_sequence_adapter< T,
+                                      ptr_container_detail::ptr_array_impl<void*,N>,
+                                      CloneAllocator >
+            base_class;
+
+        typedef BOOST_DEDUCED_TYPENAME remove_nullable<T>::type U;
+
+        typedef ptr_array<T,N,CloneAllocator>
+                          this_type;
+
+        ptr_array( const this_type& );
+        void operator=( const this_type& );
+
+    public:
+        typedef std::size_t size_type;
+        typedef U*          value_type;
+        typedef U*          pointer;
+        typedef U&          reference;
+        typedef const U&    const_reference;
+        typedef BOOST_DEDUCED_TYPENAME base_class::auto_type
+                            auto_type;
+
+    public: // constructors
+        ptr_array() : base_class()
+        { }
+
+        ptr_array( std::auto_ptr<this_type> r )
+        : base_class( r ) { }
+
+        void operator=( std::auto_ptr<this_type> r )
+        {
+            base_class::operator=(r);
+        }
+
+        std::auto_ptr<this_type> release()
+        {
+            std::auto_ptr<this_type> ptr( new this_type );
+            this->swap( *ptr );
+            return ptr;
+        }
+
+        std::auto_ptr<this_type> clone() const
+        {
+            std::auto_ptr<this_type> pa( new this_type );
+            for( size_t i = 0; i != N; ++i )
+            {
+                if( ! is_null(i) )
+                    pa->replace( i, CloneAllocator::allocate_clone( (*this)[i] ) );
+            }
+            return pa;
+        }
+
+    private: // hide some members
+        using base_class::insert;
+        using base_class::erase;
+        using base_class::push_back;
+        using base_class::push_front;
+        using base_class::pop_front;
+        using base_class::pop_back;
+        using base_class::transfer;
+        using base_class::get_allocator;
+
+    public: // compile-time interface
+
+        template< size_t idx >
+        auto_type replace( U* r ) // strong
+        {
+            BOOST_STATIC_ASSERT( idx < N );
+
+            this->enforce_null_policy( r, "Null pointer in 'ptr_array::replace()'" );
+
+            auto_type res( static_cast<U*>( this->c_private()[idx] ) ); // nothrow
+            this->c_private()[idx] = r;                                 // nothrow
+            return move(res);                                           // nothrow
+        }
+
+        template< size_t idx, class V >
+        auto_type replace( std::auto_ptr<V> r )
+        {
+            return replace<idx>( r.release() );
+        }
+
+        auto_type replace( size_t idx, U* r ) // strong
+        {
+            this->enforce_null_policy( r, "Null pointer in 'ptr_array::replace()'" );
+
+            auto_type ptr( r );
+
+            BOOST_PTR_CONTAINER_THROW_EXCEPTION( idx >= N, bad_index,
+                                                 "'replace()' aout of bounds" );
+
+            auto_type res( static_cast<U*>( this->c_private()[idx] ) ); // nothrow
+            this->c_private()[idx] = ptr.release();                     // nothrow
+            return move(res);                                           // nothrow
+        }
+
+        template< class V >
+        auto_type replace( size_t idx, std::auto_ptr<V> r )
+        {
+            return replace( idx, r.release() );
+        }
+
+        using base_class::at;
+
+        template< size_t idx >
+        T& at()
+        {
+            BOOST_STATIC_ASSERT( idx < N );
+            return (*this)[idx];
+        }
+
+        template< size_t idx >
+        const T& at() const
+        {
+            BOOST_STATIC_ASSERT( idx < N );
+            return (*this)[idx];
+        }
+
+        bool is_null( size_t idx ) const
+        {
+            return base_class::is_null(idx);
+        }
+
+        template< size_t idx >
+        bool is_null() const
+        {
+            BOOST_STATIC_ASSERT( idx < N );
+            return this->c_private()[idx] == 0;
+        }
+        
+    public: // serialization
+
+        template< class Archive >
+        void save( Archive& ar, const unsigned ) const
+        {
+            this->save_helper( ar );
+        }
+
+        template< class Archive >
+        void load( Archive& ar, const unsigned ) // basic
+        {
+            for( size_type i = 0u; i != N; ++i )
+            {
+                //
+                // Remark: pointers are not tracked,
+                // so we need not call ar.reset_object_address(v, u)
+                //
+                T* p;
+                ar & p;
+                this->replace( i, p );
+            }
+        }
+
+        BOOST_SERIALIZATION_SPLIT_MEMBER()
+
+    };
+
+    //////////////////////////////////////////////////////////////////////////////
+    // clonability
+
+    template< typename T, size_t size, typename CA >
+    inline ptr_array<T,size,CA>* new_clone( const ptr_array<T,size,CA>& r )
+    {
+        return r.clone().release();
+    }
+
+    /////////////////////////////////////////////////////////////////////////
+    // swap
+
+    template< typename T, size_t size, typename CA >
+    inline void swap( ptr_array<T,size,CA>& l, ptr_array<T,size,CA>& r )
+    {
+        l.swap(r);
+    }
+}
+
+#endif