diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/stdapis/boost/ptr_container/detail/associative_ptr_container.hpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/epoc32/include/stdapis/boost/ptr_container/detail/associative_ptr_container.hpp	Tue Mar 16 16:12:26 2010 +0000
@@ -0,0 +1,209 @@
+//
+// 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_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP
+#define BOOST_PTR_CONTAINER_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/ptr_container/detail/reversible_ptr_container.hpp>
+
+namespace boost
+{
+
+namespace ptr_container_detail
+{
+    template
+    <
+        class Config,
+        class CloneAllocator
+    >
+    class associative_ptr_container :
+        public reversible_ptr_container<Config,CloneAllocator>
+    {
+        typedef reversible_ptr_container<Config,CloneAllocator>
+                                base_type;
+
+        typedef BOOST_DEDUCED_TYPENAME base_type::scoped_deleter
+                                scoped_deleter;
+
+    public: // typedefs
+        typedef BOOST_DEDUCED_TYPENAME Config::key_type
+                                key_type;
+        typedef BOOST_DEDUCED_TYPENAME Config::key_compare
+                                key_compare;
+        typedef BOOST_DEDUCED_TYPENAME Config::value_compare
+                                value_compare;
+        typedef BOOST_DEDUCED_TYPENAME Config::iterator
+                                iterator;
+        typedef BOOST_DEDUCED_TYPENAME Config::const_iterator
+                                const_iterator;
+        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
+                                size_type;
+
+    public: // foundation
+
+       template< class Compare, class Allocator >
+       associative_ptr_container( const Compare& comp,
+                                    const Allocator& a )
+         : base_type( comp, a )
+       { }
+
+       template< class InputIterator, class Compare, class Allocator >
+       associative_ptr_container( InputIterator first, InputIterator last,
+                                    const Compare& comp,
+                                    const Allocator& a )
+         : base_type( first, last, comp, a )
+       { }
+
+       template< class PtrContainer >
+       associative_ptr_container( std::auto_ptr<PtrContainer> r )
+         : base_type( r, key_compare() )
+       { }
+
+       template< class PtrContainer >
+       void operator=( std::auto_ptr<PtrContainer> r )
+       {
+           base_type::operator=( r );
+       }
+
+    public: // associative container interface
+        key_compare key_comp() const
+        {
+            return this->c_private().key_comp();
+        }
+
+        value_compare value_comp() const
+        {
+            return this->c_private().value_comp();
+        }
+
+        iterator erase( iterator before ) // nothrow
+        {
+            BOOST_ASSERT( !this->empty() );
+            BOOST_ASSERT( before != this->end() );
+
+            this->remove( before );                      // nothrow
+            iterator res( before );                      // nothrow
+            ++res;                                       // nothrow
+            this->c_private().erase( before.base() );    // nothrow
+            return res;                                  // nothrow
+        }
+
+        size_type erase( const key_type& x ) // nothrow
+        {
+            iterator i( this->c_private().find( x ) );  // nothrow
+            if( i == this->end() )                      // nothrow
+                return 0u;                              // nothrow
+            this->remove( i );                          // nothrow
+            return this->c_private().erase( x );        // nothrow
+        }
+
+        iterator erase( iterator first,
+                        iterator last ) // nothrow
+        {
+            iterator res( last );                                // nothrow
+            if( res != this->end() )
+                ++res;                                           // nothrow
+
+            this->remove( first, last );                         // nothrow
+            this->c_private().erase( first.base(), last.base() );// nothrow
+            return res;                                          // nothrow
+        }
+
+    protected:
+
+        template< class AssociatePtrCont >
+        void multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
+                             AssociatePtrCont& from ) // strong
+        {
+            BOOST_ASSERT( (void*)&from != (void*)this );
+            BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
+
+            this->c_private().insert( *object.base() );     // strong
+            from.c_private().erase( object.base() );        // nothrow
+        }
+
+        template< class AssociatePtrCont >
+        size_type multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
+                                  BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
+                                  AssociatePtrCont& from ) // basic
+        {
+            BOOST_ASSERT( (void*)&from != (void*)this );
+            BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
+
+            size_type res = 0;
+            for( ; first != last; )
+            {
+                BOOST_ASSERT( first != from.end() );
+                this->c_private().insert( *first.base() );     // strong
+                BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator 
+                    to_delete( first );
+                ++first;
+                from.c_private().erase( to_delete.base() );    // nothrow
+                ++res;
+            }
+
+            return res;
+        }
+
+        template< class AssociatePtrCont >
+        bool single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
+                              AssociatePtrCont& from ) // strong
+        {
+            BOOST_ASSERT( (void*)&from != (void*)this );
+            BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
+
+            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
+                this->c_private().insert( *object.base() );     // strong
+            if( p.second )
+                from.c_private().erase( object.base() );        // nothrow
+
+            return p.second;
+        }
+
+        template< class AssociatePtrCont >
+        size_type single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
+                                   BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
+                                   AssociatePtrCont& from ) // basic
+        {
+            BOOST_ASSERT( (void*)&from != (void*)this );
+            BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
+
+            size_type res = 0;
+            for( ; first != last; )
+            {
+                BOOST_ASSERT( first != from.end() );
+                std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
+                    this->c_private().insert( *first.base() );     // strong
+                BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator 
+                    to_delete( first );
+                ++first;
+                if( p.second )
+                {
+                    from.c_private().erase( to_delete.base() );   // nothrow
+                    ++res;
+                }
+            }
+            return res;
+        }
+
+     }; // class 'associative_ptr_container'
+    
+} // namespace 'ptr_container_detail'
+    
+} // namespace 'boost'
+
+
+#endif