diff -Naur boost_1_47_0/boost/ptr_container/detail/void_ptr_iterator.hpp boost_1_47_0.patched/boost/ptr_container/detail/void_ptr_iterator.hpp --- boost_1_47_0/boost/ptr_container/detail/void_ptr_iterator.hpp 2008-03-22 21:45:55.000000000 +0000 +++ boost_1_47_0.patched/boost/ptr_container/detail/void_ptr_iterator.hpp 2011-09-29 13:54:40.315982719 +0100 @@ -24,6 +24,7 @@ { template < + class C, class VoidIter, class T > @@ -53,8 +54,8 @@ // // Remark: passing by value breaks vc7.1 // - template< class MutableIterator, class MutableT > - void_ptr_iterator( const void_ptr_iterator& r ) + template< class MutableContainer, class MutableIterator, class MutableT > + void_ptr_iterator( const void_ptr_iterator& r ) #ifdef BOOST_NO_SFINAE : iter_( VoidIter(const_cast(&*r.base())) ) #else @@ -123,48 +124,48 @@ }; // class 'void_ptr_iterator' - template< class VoidIter, class T > - inline void_ptr_iterator - operator+( void_ptr_iterator l, - BOOST_DEDUCED_TYPENAME void_ptr_iterator::difference_type n ) + template< class C, class VoidIter, class T > + inline void_ptr_iterator + operator+( void_ptr_iterator l, + BOOST_DEDUCED_TYPENAME void_ptr_iterator::difference_type n ) { l += n; return l; } - template< class VoidIter, class T > - inline void_ptr_iterator - operator+( BOOST_DEDUCED_TYPENAME void_ptr_iterator::difference_type n, - void_ptr_iterator r ) + template< class C, class VoidIter, class T > + inline void_ptr_iterator + operator+( BOOST_DEDUCED_TYPENAME void_ptr_iterator::difference_type n, + void_ptr_iterator r ) { r += n; return r; } - template< class VoidIter, class T > - inline void_ptr_iterator - operator-( void_ptr_iterator l, - BOOST_DEDUCED_TYPENAME void_ptr_iterator::difference_type n ) + template< class C, class VoidIter, class T > + inline void_ptr_iterator + operator-( void_ptr_iterator l, + BOOST_DEDUCED_TYPENAME void_ptr_iterator::difference_type n ) { l -= n; return l; } - template< class VoidIter, class T > - inline void_ptr_iterator - operator-( BOOST_DEDUCED_TYPENAME void_ptr_iterator::difference_type n, - void_ptr_iterator r ) + template< class C, class VoidIter, class T > + inline void_ptr_iterator + operator-( BOOST_DEDUCED_TYPENAME void_ptr_iterator::difference_type n, + void_ptr_iterator r ) { r -= n; return r; } - template< class VoidIter, class T, class VoidIterU, class U > - inline BOOST_DEDUCED_TYPENAME void_ptr_iterator::difference_type - operator-( void_ptr_iterator l, - void_ptr_iterator r ) + template< class C, class VoidIter, class T, class VoidIterU, class U > + inline BOOST_DEDUCED_TYPENAME void_ptr_iterator::difference_type + operator-( void_ptr_iterator l, + void_ptr_iterator r ) { return l.base() - r.base(); @@ -172,54 +173,54 @@ - template< class VoidIterT, class T, class VoidIterU, class U > - inline bool operator==( const void_ptr_iterator& l, - const void_ptr_iterator& r ) + template< class C, class VoidIterT, class T, class VoidIterU, class U> + inline bool operator==( const void_ptr_iterator& l, + const void_ptr_iterator& r ) { return l.base() == r.base(); } - template< class VoidIterT, class T, class VoidIterU, class U > - inline bool operator!=( const void_ptr_iterator& l, - const void_ptr_iterator& r ) + template< class C, class VoidIterT, class T, class VoidIterU, class U > + inline bool operator!=( const void_ptr_iterator& l, + const void_ptr_iterator& r ) { return l.base() != r.base(); } - template< class VoidIterT, class T, class VoidIterU, class U > - inline bool operator<( const void_ptr_iterator& l, - const void_ptr_iterator& r ) + template< class C, class VoidIterT, class T, class VoidIterU, class U > + inline bool operator<( const void_ptr_iterator& l, + const void_ptr_iterator& r ) { return l.base() < r.base(); } - template< class VoidIterT, class T, class VoidIterU, class U > - inline bool operator<=( const void_ptr_iterator& l, - const void_ptr_iterator& r ) + template< class C, class VoidIterT, class T, class VoidIterU, class U > + inline bool operator<=( const void_ptr_iterator& l, + const void_ptr_iterator& r ) { return l.base() <= r.base(); } - template< class VoidIterT, class T, class VoidIterU, class U > - inline bool operator>( const void_ptr_iterator& l, - const void_ptr_iterator& r ) + template< class C, class VoidIterT, class T, class VoidIterU, class U > + inline bool operator>( const void_ptr_iterator& l, + const void_ptr_iterator& r ) { return l.base() > r.base(); } - template< class VoidIterT, class T, class VoidIterU, class U > - inline bool operator>=( const void_ptr_iterator& l, - const void_ptr_iterator& r ) + template< class C, class VoidIterT, class T, class VoidIterU, class U > + inline bool operator>=( const void_ptr_iterator& l, + const void_ptr_iterator& r ) { return l.base() >= r.base(); } diff -Naur boost_1_47_0/boost/ptr_container/ptr_array.hpp boost_1_47_0.patched/boost/ptr_container/ptr_array.hpp --- boost_1_47_0/boost/ptr_container/ptr_array.hpp 2008-06-24 21:37:35.000000000 +0100 +++ boost_1_47_0.patched/boost/ptr_container/ptr_array.hpp 2011-09-29 12:48:07.197086584 +0100 @@ -55,12 +55,14 @@ class CloneAllocator = heap_clone_allocator > class ptr_array : public - ptr_sequence_adapter< T, + ptr_sequence_adapter< ptr_array, + T, ptr_container_detail::ptr_array_impl, CloneAllocator > { private: - typedef ptr_sequence_adapter< T, + typedef ptr_sequence_adapter< ptr_array, + T, ptr_container_detail::ptr_array_impl, CloneAllocator > base_class; diff -Naur boost_1_47_0/boost/ptr_container/ptr_circular_buffer.hpp boost_1_47_0.patched/boost/ptr_container/ptr_circular_buffer.hpp --- boost_1_47_0/boost/ptr_container/ptr_circular_buffer.hpp 2009-11-01 11:07:12.000000000 +0000 +++ boost_1_47_0.patched/boost/ptr_container/ptr_circular_buffer.hpp 2011-09-29 12:49:25.725084542 +0100 @@ -29,11 +29,13 @@ class Allocator = std::allocator > class ptr_circular_buffer : public - ptr_sequence_adapter< T, + ptr_sequence_adapter< ptr_circular_buffer, + T, boost::circular_buffer, CloneAllocator > { - typedef ptr_sequence_adapter< T, + typedef ptr_sequence_adapter< ptr_circular_buffer, + T, boost::circular_buffer, CloneAllocator > base_type; diff -Naur boost_1_47_0/boost/ptr_container/ptr_deque.hpp boost_1_47_0.patched/boost/ptr_container/ptr_deque.hpp --- boost_1_47_0/boost/ptr_container/ptr_deque.hpp 2008-06-24 21:37:35.000000000 +0100 +++ boost_1_47_0.patched/boost/ptr_container/ptr_deque.hpp 2011-09-29 12:49:56.900083730 +0100 @@ -29,11 +29,13 @@ class Allocator = std::allocator > class ptr_deque : public - ptr_sequence_adapter< T, + ptr_sequence_adapter< ptr_deque, + T, std::deque, CloneAllocator > { - typedef ptr_sequence_adapter< T, + typedef ptr_sequence_adapter< ptr_deque, + T, std::deque, CloneAllocator > base_class; diff -Naur boost_1_47_0/boost/ptr_container/ptr_list.hpp boost_1_47_0.patched/boost/ptr_container/ptr_list.hpp --- boost_1_47_0/boost/ptr_container/ptr_list.hpp 2008-06-24 21:37:35.000000000 +0100 +++ boost_1_47_0.patched/boost/ptr_container/ptr_list.hpp 2011-09-29 12:50:26.300082966 +0100 @@ -29,11 +29,13 @@ class Allocator = std::allocator > class ptr_list : public - ptr_sequence_adapter< T, + ptr_sequence_adapter< ptr_list, + T, std::list, CloneAllocator > { - typedef ptr_sequence_adapter< T, + typedef ptr_sequence_adapter< ptr_list, + T, std::list, CloneAllocator > base_class; diff -Naur boost_1_47_0/boost/ptr_container/ptr_sequence_adapter.hpp boost_1_47_0.patched/boost/ptr_container/ptr_sequence_adapter.hpp --- boost_1_47_0/boost/ptr_container/ptr_sequence_adapter.hpp 2009-11-01 11:07:12.000000000 +0000 +++ boost_1_47_0.patched/boost/ptr_container/ptr_sequence_adapter.hpp 2011-09-29 12:52:58.025079018 +0100 @@ -30,6 +30,7 @@ { template < + class C, class T, class VoidPtrSeq > @@ -46,11 +47,11 @@ typedef U value_type; typedef void_ptr_iterator< - BOOST_DEDUCED_TYPENAME VoidPtrSeq::iterator, U > + C, BOOST_DEDUCED_TYPENAME VoidPtrSeq::iterator, U > iterator; typedef void_ptr_iterator< - BOOST_DEDUCED_TYPENAME VoidPtrSeq::const_iterator, const U > + C, BOOST_DEDUCED_TYPENAME VoidPtrSeq::const_iterator, const U > const_iterator; #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) @@ -63,7 +64,7 @@ #else template< class Iter > - static U* get_pointer( void_ptr_iterator i ) + static U* get_pointer( void_ptr_iterator i ) { return static_cast( *i.base() ); } @@ -87,13 +88,13 @@ #if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) template< class Iter > - static const U* get_const_pointer( void_ptr_iterator i ) + static const U* get_const_pointer( void_ptr_iterator i ) { return static_cast( *i.base() ); } #else // BOOST_WORKAROUND template< class Iter > - static const U* get_const_pointer( void_ptr_iterator i ) + static const U* get_const_pointer( void_ptr_iterator i ) { return static_cast( *i.base() ); } @@ -112,8 +113,8 @@ } // ptr_container_detail - template< class Iterator, class T > - inline bool is_null( void_ptr_iterator i ) + template< class C, class Iterator, class T > + inline bool is_null( void_ptr_iterator i ) { return *i.base() == 0; } @@ -122,15 +123,16 @@ template < + class C, class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator > class ptr_sequence_adapter : public - ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config, + ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config, CloneAllocator > { - typedef ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config, + typedef ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config, CloneAllocator > base_type; diff -Naur boost_1_47_0/boost/ptr_container/ptr_set_adapter.hpp boost_1_47_0.patched/boost/ptr_container/ptr_set_adapter.hpp --- boost_1_47_0/boost/ptr_container/ptr_set_adapter.hpp 2009-04-05 20:55:59.000000000 +0100 +++ boost_1_47_0.patched/boost/ptr_container/ptr_set_adapter.hpp 2011-09-29 13:42:37.367001525 +0100 @@ -27,6 +27,7 @@ { template < + class C, class Key, class VoidPtrSet, bool Ordered @@ -72,14 +73,15 @@ container_type; typedef void_ptr_iterator< - BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key > + C, BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key > iterator; typedef void_ptr_iterator< - BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key > + C, BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key > const_iterator; typedef void_ptr_iterator< + C, BOOST_DEDUCED_TYPENAME mpl::eval_if_c, @@ -88,6 +90,7 @@ local_iterator; typedef void_ptr_iterator< + C, BOOST_DEDUCED_TYPENAME mpl::eval_if_c, @@ -114,16 +117,17 @@ template < + class C, class Key, class VoidPtrSet, class CloneAllocator = heap_clone_allocator, bool Ordered = true > class ptr_set_adapter_base - : public ptr_container_detail::associative_ptr_container< set_config, + : public ptr_container_detail::associative_ptr_container< set_config, CloneAllocator > { - typedef ptr_container_detail::associative_ptr_container< set_config, + typedef ptr_container_detail::associative_ptr_container< set_config, CloneAllocator > base_type; public: @@ -173,8 +177,8 @@ : base_type( first, last, hash, pred, a ) { } - template< class U, class Set, class CA, bool b > - ptr_set_adapter_base( const ptr_set_adapter_base& r ) + template< class C2, class U, class Set, class CA, bool b > + ptr_set_adapter_base( const ptr_set_adapter_base& r ) : base_type( r ) { } @@ -291,15 +295,16 @@ template < + class C, class Key, class VoidPtrSet, class CloneAllocator = heap_clone_allocator, bool Ordered = true > class ptr_set_adapter : - public ptr_container_detail::ptr_set_adapter_base + public ptr_container_detail::ptr_set_adapter_base { - typedef ptr_container_detail::ptr_set_adapter_base + typedef ptr_container_detail::ptr_set_adapter_base base_type; public: // typedefs @@ -380,8 +385,8 @@ : base_type( r ) { } - template< class U, class Set, class CA, bool b > - explicit ptr_set_adapter( const ptr_set_adapter& r ) + template< class C2, class U, class Set, class CA, bool b > + explicit ptr_set_adapter( const ptr_set_adapter& r ) : base_type( r ) { } @@ -390,8 +395,8 @@ : base_type( clone ) { } - template< class U, class Set, class CA, bool b > - ptr_set_adapter& operator=( const ptr_set_adapter& r ) + template< class C2, class U, class Set, class CA, bool b > + ptr_set_adapter& operator=( const ptr_set_adapter& r ) { base_type::operator=( r ); return *this; @@ -503,15 +508,16 @@ template < + class C, class Key, class VoidPtrMultiSet, class CloneAllocator = heap_clone_allocator, bool Ordered = true > class ptr_multiset_adapter : - public ptr_container_detail::ptr_set_adapter_base + public ptr_container_detail::ptr_set_adapter_base { - typedef ptr_container_detail::ptr_set_adapter_base base_type; + typedef ptr_container_detail::ptr_set_adapter_base base_type; public: // typedefs @@ -580,8 +586,8 @@ : base_type( first, last, hash, pred, a ) { } - template< class U, class Set, class CA, bool b > - explicit ptr_multiset_adapter( const ptr_multiset_adapter& r ) + template< class C2, class U, class Set, class CA, bool b > + explicit ptr_multiset_adapter( const ptr_multiset_adapter& r ) : base_type( r ) { } @@ -590,8 +596,8 @@ : base_type( clone ) { } - template< class U, class Set, class CA, bool b > - ptr_multiset_adapter& operator=( const ptr_multiset_adapter& r ) + template< class C2, class U, class Set, class CA, bool b > + ptr_multiset_adapter& operator=( const ptr_multiset_adapter& r ) { base_type::operator=( r ); return *this; diff -Naur boost_1_47_0/boost/ptr_container/.ptr_set_adapter.hpp.swp boost_1_47_0.patched/boost/ptr_container/.ptr_set_adapter.hpp.swp --- boost_1_47_0/boost/ptr_container/.ptr_set_adapter.hpp.swp 1970-01-01 01:00:00.000000000 +0100 +++ boost_1_47_0.patched/boost/ptr_container/.ptr_set_adapter.hpp.swp 2011-09-29 13:42:41.422001417 +0100 @@ -0,0 +1,62 @@ +b0VIM 7.3gN4robdlocalhost.localdomain~robd/bits/boost_1_47_0.patched/boost/ptr_container/ptr_set_adapter.hpputf-8 3210#"! Utp +{:|% 5 +^!n E`h3ad{\!zJI N $ #   p j O & % d c <  + + + +c +B +A + + p o H % pRE'&cY6}YX6, ]D|{](r_D class CloneAllocator = heap_clone_allocator, class VoidPtrSet, class Key, class C, < template }; BOOST_STATIC_CONSTANT(bool, allow_null = false ); } return static_cast( *i.base() ); { static const Key* get_const_pointer( Iter i ) template< class Iter > } return static_cast( *i.base() ); { static Key* get_pointer( Iter i ) template< class Iter > const_local_iterator; const Key > select_const_local_iterator >::type, select_iterator, mpl::eval_if_c select_local_iterator >::type, select_iterator, mpl::eval_if_c typedef void_ptr_iterator< iterator; C, BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key > typedef void_ptr_iterator< container_type; unordered_associative_container_tag>::type ordered_associative_container_tag, mpl::if_c >::type mpl::identity, mpl::eval_if_c >::type mpl::identity, mpl::eval_if_c >::type select_value_compare, mpl::eval_if_c bool Ordered class VoidPtrSet, class Key, class C, < template{namespace ptr_container_detail{namespace boost#include #include #include #include #endif# pragma once#if defined(_MSC_VER) && (_MSC_VER >= 1200)#define BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP#ifndef BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP//// For more information, see http://www.boost.org/libs/ptr_container///// http://www.boost.org/LICENSE_1_0.txt)// 1.0. (See accompanying file LICENSE_1_0.txt or copy at// distribution is subject to the Boost Software License, Version// Copyright Thorsten Ottosen 2003-2005. Use, modification and//// Boost.Pointer Container//ad 5 si+! B V L K < ;  q g ^ W V = < 5 4 #endif} // namespace 'boost' }; } BOOST_ASSERT( from.empty() ); transfer( from.begin(), from.end(), from ); { void transfer( PtrSetAdapter& from ) // basic template< class PtrSetAdapter >#endif } return transfer( boost::begin(r), boost::end(r), from ); { transfer( const Range& r, PtrSetAdapter& from ) // basic BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, size_type >::type BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range, template< class PtrSetAdapter, class Range > #else #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) } return this->multi_transfer( first, last, from ); { PtrSetAdapter& from ) // basic BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, ad:NT;- i I d  c /    + +e +2 + + + p = }6pdT}bG;*B8si>$w<O return res; this->remove( key ); // nothrow size_type res = this->base().erase( key ); // nothrow key = static_cast(*i.base()); // nothrow return 0u; // nothrow if( i == this->end() ) // nothrow iterator i( this->base().find( key ) ); key_type* key = const_cast(&x); { size_type erase( const key_type& x ) // nothrow using base_type::erase; } return *this; base_type::operator=( clone ); { ptr_set_adapter_base& operator=( std::auto_ptr clone ) template< typename PtrContainer > } return *this; this->swap( r ); { ptr_set_adapter_base& operator=( ptr_set_adapter_base r ) { } : base_type( clone ) explicit ptr_set_adapter_base( std::auto_ptr clone ) template< class PtrContainer > { } : base_type( r ) ptr_set_adapter_bas ptr_set_adapter_base( const ptr_set_adapter_base& ptr_set_adapter_base( const ptr_set_adapter_base& r ) template< class C2, class U, class Set, class CA, bool b > { } : base_type( first, last, hash, pred, a ) const Allocator& a ) const Pred& pred, const Hash& hash, ptr_set_adapter_base( InputIterator first, InputIterator last, template< class InputIterator, class Hash, class Pred, class Allocator > { } : base_type( first, last, comp, a ) const Allocator& a ) const Compare& comp, ptr_set_adapter_base( InputIterator first, InputIterator last, template< class InputIterator, class Compare, class Allocator > { } : base_type( hash, pred, a ) const Allocator& a ) const Pred& pred, ptr_set_adapter_base( const Hash& hash, template< class Hash, class Pred, class Allocator > { } : base_type( comp, a ) const Allocator& a ) ptr_set_adapter_base( const Compare& comp, template< class Compare, class Allocator > { } : base_type( n, tag ) ptr_container_detail::unordered_associative_container_tag tag ) ptr_set_adapter_base( SizeType n, template< class SizeType > { } ptr_set_adapter_base() public: size_type; typedef BOOST_DEDUCED_TYPENAME base_type::size_type typedef Key key_type; const_iterator; typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator iterator; typedef BOOST_DEDUCED_TYPENAME base_type::iterator public: base_type; CloneAllocator > typedef ptr_container_detail::associative_ptr_container< set_config, { CloneAllocator > : public ptr_container_detail::associative_ptr_container< set_config, class ptr_set_adapter_base > bool Ordered = truead + +%sb;zpS9/& v \ R Q 1 ( t % 7 + + return res; this->remove( key ); // nothrow size_type res = this->base().erase( key ); // nothrow key = static_cast(*i.base()); // nothrow return 0u; // nothrow if( i == this->end() ) // nothrow iterator i( this->base().find( key ) ); key_type* key = const_cast(&x); { size_type erase( const key_type& x ) // nothrow using base_type::erase; } return *this; base_type::operator=( clone ); { ptr_set_adapter_base& operator=( std::auto_ptr clone ) template< typename PtrContainer > } return *this; this->swap( r ); { ptr_set_adapter_base& operator=( ptr_set_adapter_base r ) { } : base_type( clone ) explicit ptr_set_adapter_base( std::auto_ptr clone ) template< class PtrContainer > { } : base_type( r ) ptr_set_adapter_base( const ptr_set_adapter_base& r ) { } : base_type( r )ad} + !uG ut# ] )   t (  m a `  + + + + + +h +: +0 + + C 6 s%}|`"<;4[Q  YONX7- template< class PtrSetAdapter >#endif } insert( boost::begin(r), boost::end(r) ); { insert( const Range& r ) boost::disable_if< ptr_container_detail::is_pointer_or_integral >::type BOOST_DEDUCED_TYPENAME template< class Range > #else #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) } set_basic_clone_and_insert( first, last ); { void insert( InputIterator first, InputIterator last ) // basic template< typename InputIterator > } return insert( where, x.release() ); { iterator insert( iterator where, std::auto_ptr x ) template< class U > } return iterator( res); ptr.release(); if( *res == x ) res = this->base().insert( where.base(), x ); BOOST_DEDUCED_TYPENAME base_type::ptr_iterator auto_type ptr( x ); this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" ); { iterator insert( iterator where, key_type* x ) // strong } return insert( x.release() ); { std::pair insert( std::auto_ptr x ) template< class U > } return std::make_pair( iterator( res.first ), res.second ); ptr.release(); if( res.second ) res = this->base().insert( x ); std::pair auto_type ptr( x ); this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" ); { std::pair insert( key_type* x ) // strong } base_type::operator=( r ); { void operator=( std::auto_ptr r ) template< class T > } return *this; base_type::operator=( r ); { ptr_set_a template< clclass U, class Set, class CA, template< class C2, class U, class Set, class CA, bool b > { } : base_type( clone ) explicit ptr_set_adapter( std::auto_ptr clone ) template< class PtrContainer > { } : base_type( r ) explicit ptr_set_adapter( const ptr_set_adapter& r ) template< class C2, class U, class Set, class CA, bool b > { } : base_type( r ) explicit ptr_set_adapter( const ptr_set_adapter& r ) { } : base_type( first, last, hash, pred, a ) const Allocator& a ) const Pred& pred, const Hash& hash, ptr_set_adapter( InputIterator first, InputIterator last, template< class InputIterator, class Hash, class Pred, class Allocator > } set_basic_clone_and_insert( first, last ); BOOST_ASSERT( this->empty() ); { : base_type( comp, a ) const Allocator a = Allocator() ) const Compare& comp, ptr_set_adapter( InputIterator first, InputIterator last, template< class InputIterator, class Compare, class Allocator >ad`zp6,+_.$ M  h '  b X      + +J +I +< +5 +( + + s  sn0J(V~ +mJE9 aA54{on2 const Allocator& a ) const Pred& pred, ptr_multiset_adapter( const Hash& hash, template< class Hash, class Pred, class Allocator > { } : base_type( comp, a ) const allocator_type& a ) explicit ptr_multiset_adapter( const Comp& comp, template< class Comp > { } : base_type( n, tag ) ptr_container_detail::unordered_associative_container_tag tag ) ptr_multiset_adapter( SizeType n, template< class SizeType > { } ptr_multiset_adapter() public: } } ++first; insert( CloneAllocator::allocate_clone( *first ) ); // strong, commit { while( first != last ) { void set_basic_clone_and_insert( II first, II last ) // basic template< typename II > private: allocator_type; typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiSet::allocator_type auto_type; typedef BOOST_DEDUCED_TYPENAME base_type::auto_type typedef Key key_type; size_type; typedef BOOST_DEDUCED_TYPENAME base_type::size_type iterator; typedef BOOST_DEDUCED_TYPENAME base_type::iterator public: // typedefs typedef ptr_container_detail::ptr_set_adapter_base base_type; { public ptr_container_detail::ptr_set_adapter_base class ptr_multiset_adapter : > bool Ordered = true class CloneAllocator = heap_clone_allocator, class VoidPtrMultiSet, class Key, class C, < template ///////////////////////////////////////////////////////////////////////// // ptr_multiset_adapter ///////////////////////////////////////////////////////////////////////// }; } return transfer( from.begin(), from.end(), from ); { size_type transfer( PtrSetAdapter& from ) // basic template< class PtrSetAdapter >#endif } return transfer( boost::begin(r), boost::end(r), from ); { transfer( const Range& r, PtrSetAdapter& from ) // basic size_type >::type BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range, template< class PtrSetAdapter, class Range >#else #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) } return this->single_transfer( first, last, from ); { PtrSetAdapter& from ) // basic BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, size_type template< class PtrSetAdapter > } return this->single_transfer( object, from ); { PtrSetAdapter& from ) // strong bool transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, adh]9-$y. q * d X G  ~ W + + + +E +; + + k a `   wm;1,pk+U{qlA`VM-VLKDCYON& size_type transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, template< class PtrSetAdapter > } this->multi_transfer( object, from ); { PtrSetAdapter& from ) // strong void transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, template< class PtrSetAdapter >#endif } insert( boost::begin(r), boost::end(r) ); { insert( const Range& r ) boost::disable_if< ptr_container_detail::is_pointer_or_integral >::type BOOST_DEDUCED_TYPENAME template< class Range > #else #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) } set_basic_clone_and_insert( first, last ); { void insert( InputIterator first, InputIterator last ) // basic template< typename InputIterator > } return insert( x.release() ); { iterator insert( std::auto_ptr x ) template< class U > } return iterator( res ); ptr.release(); res = this->base().insert( x ); BOOST_DEDUCED_TYPENAME base_type::ptr_iterator auto_type ptr( x ); this->enforce_null_policy( x, "Null pointer in 'ptr_multiset::insert()'" ); { iterator insert( key_type* x ) // strong } return insert( before, x.release() ); { iterator insert( iterator before, std::auto_ptr x ) template< class U > } return base_type::insert( before, x ); { iterator insert( iterator before, key_type* x ) // strong } base_type::operator=( r ); { void operator=( std::auto_ptr r ) template< class T > } return *this; base_type::operator=( r ); { ptr_multiset_adapter& operator=( const ptr_multiset_adapter& r ) template< class C2, class U, class Set, class CA, bool b > { } : base_type( clone ) explicit ptr_multiset_adapter( std::auto_ptr clone ) template< class PtrContainer > { } : base_type( r ) explicit ptr_multiset_adapter( const ptr_multiset_adapter& r ) template< class C2, class U, class Set, class CA, bool b > { } : base_type( first, last, hash, pred, a ) const Allocator& a ) const Pred& pred, const Hash& hash, ptr_multiset_adapter( InputIterator first, InputIterator last, template< class InputIterator, class Hash, class Pred, class Allocator > } set_basic_clone_and_insert( first, last ); { : base_type( comp, a ) const allocator_type& a = allocator_type() ) const Comp& comp, ptr_multiset_adapter( InputIterator first, InputIterator last, template< class InputIterator, class Comp > { } : base_type( first, last ) ptr_multiset_adapter( InputIterator first, InputIterator last ) template< class InputIterator > { } : base_type( hash, pred, a )ad9)5Cts 7 /  ) +x +M + E c a1*GEb@)( } iterator( p.second ) ); return make_iterator_range( iterator( p.first ), equal_range( const_cast(&x) ); p = this->base(). BOOST_DEDUCED_TYPENAME base_type::ptr_iterator> std::pair equal_range( const key_type& x ) } upper_bound( const_cast(&x) ) ); return const_iterator( this->base(). { const_iterator upper_bound( const key_type& x ) const } upper_bound( const_cast(&x) ) ); return iterator( this->base(). { iterator upper_bound( const key_type& x ) } lower_bound( const_cast(&x) ) ); return const_iterator( this->base(). { const_iterator lower_bound( const key_type& x ) const } lower_bound( const_cast(&x) ) ); return iterator( this->base(). { iterator lower_bound( const key_type& x ) } return this->base().count( const_cast(&x) ); { size_type count( const key_type& x ) const } find( const_cast(&x) ) ); return const_iterator( this->base(). { const_iterator find( const key_type& x ) const } find( const_cast(&x) ) ); return iterator( this->base(). { iterator find( const key_type& x ) }ad^ZkI r q b , " ` I u Q K . + +` +I +D +, +$ + x B  g%<KS0/# Z:.%si=32rL@? { } : base_type( first, last ) ptr_set_adapter( InputIterator first, InputIterator last ) template< class InputIterator > { } : base_type( hash, pred, a ) const Allocator& a ) const Pred& pred, ptr_set_adapter( const Hash& hash, template< class Hash, class Pred, class Allocator > } BOOST_ASSERT( this->empty() ); { : base_type( comp, a ) const allocator_type& a ) explicit ptr_set_adapter( const Comp& comp, template< class Comp > { } : base_type( n, tag ) ptr_container_detail::unordered_associative_container_tag tag ) ptr_set_adapter( SizeType n, template< class SizeType > { } ptr_set_adapter() public: } } ++first; insert( CloneAllocator::allocate_clone( *first ) ); // strong, commit if( this->find( *first ) == this->end() ) { while( first != last ) { void set_basic_clone_and_insert( II first, II last ) // basic template< typename II > private: allocator_type; typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type auto_type; typedef BOOST_DEDUCED_TYPENAME base_type::auto_type typedef Key key_type; size_type; typedef BOOST_DEDUCED_TYPENAME base_type::size_type const_iterator; typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator iterator; typedef BOOST_DEDUCED_TYPENAME base_type::iterator public: // typedefs base_type; typedef ptr_container_detail::ptr_set_adapter_base { public ptr_container_detail::ptr_set_adapter_base class ptr_set_adapter : > bool Ordered = true class CloneAllocator = heap_clone_allocator, class VoidPtrSet, class Key, class C, < template ///////////////////////////////////////////////////////////////////////// // ptr_set_adapter /////////////////////////////////////////////////////////////////////////} // ptr_container_detail }; } return this->base().bucket( const_cast(&key) ); { size_type bucket( const key_type& key ) const protected: } const_iterator( p.second ) ); return make_iterator_range( const_iterator( p.first ), equal_range( const_cast(&x) ); p = this->base(). BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator> std::pair equal_range( const key_type& x ) const ad[Ef\[?~m  J ^ T S 7 p f   + +X + + p 2 ( qg0&%/ template< class PtrSetAdapter >#endif } insert( boost::begin(r), boost::end(r) ); { insert( const Range& r ) boost::disable_if< ptr_container_detail::is_pointer_or_integral >::type BOOST_DEDUCED_TYPENAME template< class Range > #else #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) } set_basic_clone_and_insert( first, last ); { void insert( InputIterator first, InputIterator last ) // basic template< typename InputIterator > } return insert( where, x.release() ); { iterator insert( iterator where, std::auto_ptr x ) template< class U > } return iterator( res); ptr.release(); if( *res == x ) res = this->base().insert( where.base(), x ); BOOST_DEDUCED_TYPENAME base_type::ptr_iterator auto_type ptr( x ); this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" ); { iterator insert( iterator where, key_type* x ) // strong } return insert( x.release() ); { std::pair insert( std::auto_ptr x ) template< class U > } return std::make_pair( iterator( res.first ), res.second ); ptr.release(); if( res.second ) res = this->base().insert( x ); std::pair auto_type ptr( x ); this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" ); { std::pair insert( key_type* x ) // strong } base_type::operator=( r ); { void operator=( std::auto_ptr r ) template< class T > } return *this; base_type::operator=( r ); { ptr_set_adapter& operator=( const ptr_set_adapter& r ) \ No newline at end of file diff -Naur boost_1_47_0/boost/ptr_container/ptr_set.hpp boost_1_47_0.patched/boost/ptr_container/ptr_set.hpp --- boost_1_47_0/boost/ptr_container/ptr_set.hpp 2008-06-24 21:37:35.000000000 +0100 +++ boost_1_47_0.patched/boost/ptr_container/ptr_set.hpp 2011-09-29 13:37:53.921008898 +0100 @@ -31,11 +31,13 @@ class Allocator = std::allocator > class ptr_set : - public ptr_set_adapter< Key, + public ptr_set_adapter< ptr_set, + Key, std::set,Allocator>, CloneAllocator, true > { - typedef ptr_set_adapter< Key, std::set,Allocator>, + typedef ptr_set_adapter< ptr_set, + Key, std::set,Allocator>, CloneAllocator, true > base_type; @@ -80,11 +82,13 @@ class Allocator = std::allocator > class ptr_multiset : - public ptr_multiset_adapter< Key, + public ptr_multiset_adapter< ptr_multiset, + Key, std::multiset,Allocator>, CloneAllocator, true > { - typedef ptr_multiset_adapter< Key, + typedef ptr_multiset_adapter< ptr_multiset, + Key, std::multiset,Allocator>, CloneAllocator, true > base_type; diff -Naur boost_1_47_0/boost/ptr_container/ptr_unordered_set.hpp boost_1_47_0.patched/boost/ptr_container/ptr_unordered_set.hpp --- boost_1_47_0/boost/ptr_container/ptr_unordered_set.hpp 2008-06-24 21:37:35.000000000 +0100 +++ boost_1_47_0.patched/boost/ptr_container/ptr_unordered_set.hpp 2011-09-29 13:39:19.542006672 +0100 @@ -32,12 +32,14 @@ class Allocator = std::allocator > class ptr_unordered_set : - public ptr_set_adapter< Key, + public ptr_set_adapter< ptr_unordered_set, + Key, boost::unordered_set, void_ptr_indirect_fun,Allocator>, CloneAllocator, false > { - typedef ptr_set_adapter< Key, + typedef ptr_set_adapter< ptr_unordered_set, + Key, boost::unordered_set, void_ptr_indirect_fun,Allocator>, CloneAllocator, false > @@ -122,12 +124,14 @@ class Allocator = std::allocator > class ptr_unordered_multiset : - public ptr_multiset_adapter< Key, + public ptr_multiset_adapter< ptr_unordered_multiset, + Key, boost::unordered_multiset, void_ptr_indirect_fun,Allocator>, CloneAllocator, false > { - typedef ptr_multiset_adapter< Key, + typedef ptr_multiset_adapter< ptr_unordered_multiset, + Key, boost::unordered_multiset, void_ptr_indirect_fun,Allocator>, CloneAllocator, false > diff -Naur boost_1_47_0/boost/ptr_container/ptr_vector.hpp boost_1_47_0.patched/boost/ptr_container/ptr_vector.hpp --- boost_1_47_0/boost/ptr_container/ptr_vector.hpp 2008-06-24 21:37:35.000000000 +0100 +++ boost_1_47_0.patched/boost/ptr_container/ptr_vector.hpp 2011-09-29 12:50:48.982082374 +0100 @@ -29,11 +29,13 @@ class Allocator = std::allocator > class ptr_vector : public - ptr_sequence_adapter< T, + ptr_sequence_adapter< ptr_vector, + T, std::vector, CloneAllocator > { - typedef ptr_sequence_adapter< T, + typedef ptr_sequence_adapter< ptr_vector, + T, std::vector, CloneAllocator > base_class;