Ticket #11620: boost_ptr_no_auto.patch

boost/ptr_container/detail/associative_ptr_container.hpp

@@ -103 +103 @@
          : base_type( first, last, hash, pred, a )
         { }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         explicit associative_ptr_container( std::auto_ptr<PtrContainer> r )
          : base_type( r )
         { }
+#endif
 
         associative_ptr_container( const associative_ptr_container& r )
          : base_type( r.begin(), r.end(), container_type() )
@@ -117 +119 @@
          : base_type( r.begin(), r.end(), container_type() )
         { }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         associative_ptr_container& operator=( std::auto_ptr<PtrContainer> r ) // nothrow
         {
            base_type::operator=( r );
            return *this;
         }
+#endif
         
         associative_ptr_container& operator=( associative_ptr_container r ) // strong
         {

boost/ptr_container/detail/reversible_ptr_container.hpp

@@ -337 +337 @@
          : c_( a )
         { }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         explicit reversible_ptr_container( std::auto_ptr<PtrContainer> clone )                
         { 
             swap( *clone ); 
         }
+#endif
 
         reversible_ptr_container( const reversible_ptr_container& r ) 
         {
@@ -354 +356 @@
             constructor_impl( r.begin(), r.end(), std::forward_iterator_tag() ); 
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         reversible_ptr_container& operator=( std::auto_ptr<PtrContainer> clone ) // nothrow
         {
             swap( *clone );
             return *this;
         }
+#endif
 
         reversible_ptr_container& operator=( reversible_ptr_container r ) // strong 
         {
@@ -568 +572 @@
             return res;
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( iterator before, std::auto_ptr<U> x )
         {
             return insert( before, x.release() );
         }
-
+#endif
         iterator erase( iterator x ) // nothrow
         {
             BOOST_ASSERT( !empty() );
@@ -632 +637 @@
             return boost::ptr_container_detail::move( old );
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         auto_type replace( iterator where, std::auto_ptr<U> x )
         {
             return replace( where, x.release() ); 
         }
-
+#endif
         auto_type replace( size_type idx, Ty_* x ) // strong
         {
             enforce_null_policy( x, "Null pointer in 'replace()'" );
@@ -652 +658 @@
             return boost::ptr_container_detail::move( old );
         } 
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         auto_type replace( size_type idx, std::auto_ptr<U> x )
         {
             return replace( idx, x.release() );
         }
-                
+#endif
+
     }; // 'reversible_ptr_container'
 
 
@@ -677 +685 @@
     // two-phase lookup of template functions 
     // is buggy on most compilers, so we use a macro instead
     //
+
+#ifndef BOOST_NO_AUTO_PTR
+
 #define BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( PC, base_type, this_type ) \
     explicit PC( std::auto_ptr<this_type> r )       \
     : base_type ( r ) { }                           \
@@ -700 +711 @@
        return std::auto_ptr<this_type>( new this_type( this->begin(), this->end() ) ); \
     }
 
+#else
+
+#define BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( PC, base_type, this_type )
+
+#endif
+
 #define BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( PC, base_type ) \
                                                                       \
     template< class U >                                               \
@@ -725 +742 @@
     PC( InputIterator first, InputIterator last,                                       \
         const allocator_type& a ) : base_type( first, last, a ) {}  
                  
+
 #define BOOST_PTR_CONTAINER_DEFINE_NON_INHERITED_MEMBERS( PC, base_type, this_type )           \
    BOOST_PTR_CONTAINER_DEFINE_CONSTRUCTORS( PC, base_type )                                    \
    BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( PC, base_type, this_type )

boost/ptr_container/ptr_array.hpp

@@ -100 +100 @@
                                         static_cast<const T*>( &r[i] ) ); 
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         explicit ptr_array( std::auto_ptr<this_type> r )
         : base_class( r ) { }
+#endif
 
         ptr_array& operator=( ptr_array r )
         {
@@ -109 +111 @@
             return *this;            
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         ptr_array& operator=( std::auto_ptr<this_type> r )
         {
             base_class::operator=(r);
@@ -132 +135 @@
             }
             return pa;
         }
+#endif
 
     private: // hide some members
         using base_class::insert;
@@ -157 +161 @@
             return boost::ptr_container::move(res);                // nothrow 
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< size_t idx, class V >
         auto_type replace( std::auto_ptr<V> r )
         {
             return replace<idx>( r.release() );
         }
+#endif
 
         auto_type replace( size_t idx, U* r ) // strong
         {
@@ -177 +183 @@
             return boost::ptr_container::move(res);                // nothrow 
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class V >
         auto_type replace( size_t idx, std::auto_ptr<V> r )
         {
             return replace( idx, r.release() );
         }
+#endif
 
         using base_class::at;
 

boost/ptr_container/ptr_circular_buffer.hpp

@@ -293 +293 @@
             this->base().push_back( ptr );            
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         void push_back( std::auto_ptr<U> ptr ) // nothrow
         {
             push_back( ptr.release() ); 
         }
+#endif
 
         void push_front( value_type ptr ) // nothrow
         {
@@ -310 +312 @@
             this->base().push_front( ptr );            
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         void push_front( std::auto_ptr<U> ptr ) // nothrow
         {
             push_front( ptr.release() ); 
         }
+#endif
 
         iterator insert( iterator pos, value_type ptr ) // nothrow
         {
@@ -334 +338 @@
             return this->base().insert( pos.base(), ptr );
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( iterator pos, std::auto_ptr<U> ptr ) // nothrow
         {
             return insert( pos, ptr.release() );
         }
+#endif
 
         template< class InputIterator >
         void insert( iterator pos, InputIterator first, InputIterator last ) // basic
@@ -377 +383 @@
             return this->base().rinsert( pos.base(), ptr );
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator rinsert( iterator pos, std::auto_ptr<U> ptr ) // nothrow
         {
             return rinsert( pos, ptr.release() );
         }
-
+#endif
  
         template< class InputIterator >
         void rinsert( iterator pos, InputIterator first, InputIterator last ) // basic

boost/ptr_container/ptr_inserter.hpp

@@ -73 +73 @@
             return *this;
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class T >
         ptr_back_insert_iterator& 
         operator=( std::auto_ptr<T> r )
@@ -80 +81 @@
             container->push_back( r );
             return *this;
         }
+#endif
 
         ptr_back_insert_iterator& 
         operator=( typename PtrContainer::const_reference r )
@@ -133 +135 @@
             return *this;
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class T >
         ptr_front_insert_iterator& 
         operator=( std::auto_ptr<T> r )
@@ -140 +143 @@
             container->push_front( r );
             return *this;
         }
-        
+#endif
+
         ptr_front_insert_iterator& 
         operator=( typename PtrContainer::const_reference r )
         {
@@ -194 +198 @@
             return *this;
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class T >
         ptr_insert_iterator& 
         operator=( std::auto_ptr<T> r )
@@ -201 +206 @@
             iter = container->insert( iter, r );
             return *this;
         }
+#endif
         
         ptr_insert_iterator& 
         operator=( typename PtrContainer::const_reference r )

boost/ptr_container/ptr_map_adapter.hpp

@@ -260 +260 @@
                               const Allocator& a )
          : base_type( first, last, hash, pred, a )
         { }
-                
+
+#ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         explicit ptr_map_adapter_base( std::auto_ptr<PtrContainer> clone ) 
         : base_type( clone )
         { }
-        
+
         template< typename PtrContainer >
         ptr_map_adapter_base& operator=( std::auto_ptr<PtrContainer> clone )    
         {
             base_type::operator=( clone );
             return *this;
         }        
-
+#endif
         iterator find( const key_type& x )                                                
         {                                                                            
             return iterator( this->base().find( x ) );                                
@@ -357 +358 @@
             return boost::ptr_container::move( old );
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         auto_type replace( iterator where, std::auto_ptr<U> x )
         {
             return replace( where, x.release() );
         }
+#endif
 
     protected:
         size_type bucket( const key_type& key ) const
@@ -487 +490 @@
             map_basic_clone_and_insert( r.begin(), r.end() );      
         }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         ptr_map_adapter( std::auto_ptr<U> r ) : base_type( r )
         { }
-
+#endif
         ptr_map_adapter& operator=( ptr_map_adapter r )
         {
             this->swap( r );
             return *this;
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         ptr_map_adapter& operator=( std::auto_ptr<U> r )
         {  
             base_type::operator=( r );
             return *this;
         }
-
+#endif
         using base_type::release;
 
         template< typename InputIterator >
@@ -550 +555 @@
             return insert_impl( key, x );
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         std::pair<iterator,bool> insert( const key_type& key, std::auto_ptr<U> x )
         {
             return insert_impl( key, x.release() );
         }
-
+#endif
         template< class F, class S >
         iterator insert( iterator before, ptr_container_detail::ref_pair<F,S> p ) // strong
         {
@@ -577 +583 @@
             return insert_impl( before, key, x );
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( iterator before, const key_type& key, std::auto_ptr<U> x ) // strong
         {
             return insert_impl( before, key, x.release() );
         }
-        
+#endif
+
         template< class PtrMapAdapter >
         bool transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator object, 
                        PtrMapAdapter& from ) // strong
@@ -736 +744 @@
             map_basic_clone_and_insert( r.begin(), r.end() );      
         }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         explicit ptr_multimap_adapter( std::auto_ptr<U> r ) : base_type( r )
         { }
+#endif
 
         ptr_multimap_adapter& operator=( ptr_multimap_adapter r )
         {
@@ -746 +756 @@
             return *this;
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         ptr_multimap_adapter& operator=( std::auto_ptr<U> r )
         {  
             base_type::operator=( r );
             return *this;
         }
+#endif
 
         using base_type::release;
 
@@ -799 +811 @@
             return insert_impl( key, x );
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( const key_type& key, std::auto_ptr<U> x )
         {
             return insert_impl( key, x.release() );
         }
-
+#endif
         template< class F, class S >
         iterator insert( iterator before, ptr_container_detail::ref_pair<F,S> p ) // strong
         {
@@ -820 +833 @@
             return insert_impl( before, key, x );
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( iterator before, const key_type& key, std::auto_ptr<U> x ) // strong
         {
             return insert_impl( before, key, x.release() );
         }
+#endif
         
         template< class PtrMapAdapter >
         void transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator object, 

boost/ptr_container/ptr_sequence_adapter.hpp

@@ -219 +219 @@
           : base_type( r, tag )
         { }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         explicit ptr_sequence_adapter( std::auto_ptr<PtrContainer> clone )
           : base_type( clone )
         { }
-
+#endif
         ptr_sequence_adapter& operator=( const ptr_sequence_adapter r )
         {
             this->swap( r );
             return *this; 
         }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         ptr_sequence_adapter& operator=( std::auto_ptr<PtrContainer> clone )    
         {
             base_type::operator=( clone );
             return *this;
         }
-
+#endif
         /////////////////////////////////////////////////////////////
         // modifiers
         /////////////////////////////////////////////////////////////
@@ -250 +252 @@
             ptr.release();                // nothrow
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         void push_back( std::auto_ptr<U> x )
         {
             push_back( x.release() );
         }
-        
+#endif
+
         void push_front( value_type x )                
         {
             this->enforce_null_policy( x, "Null pointer in 'push_front()'" );
@@ -265 +269 @@
             ptr.release();                // nothrow
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         void push_front( std::auto_ptr<U> x )
         {
             push_front( x.release() );
         }
-
+#endif
         auto_type pop_back()
         {
             BOOST_ASSERT( !this->empty() && 

boost/ptr_container/ptr_set_adapter.hpp

@@ -182 +182 @@
           : base_type( r )
         { }
                 
+#ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         explicit ptr_set_adapter_base( std::auto_ptr<PtrContainer> clone )
          : base_type( clone )
         { }
-        
+#endif
+
         ptr_set_adapter_base& operator=( ptr_set_adapter_base r ) 
         {
             this->swap( r );
             return *this;
         }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< typename PtrContainer >
         ptr_set_adapter_base& operator=( std::auto_ptr<PtrContainer> clone )    
         {
             base_type::operator=( clone );
             return *this;
         }
+#endif
 
         using base_type::erase;
         
@@ -385 +389 @@
           : base_type( r )
         { }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         explicit ptr_set_adapter( std::auto_ptr<PtrContainer> clone )
          : base_type( clone )
         { }
-
+#endif
         template< class U, class Set, class CA, bool b >
         ptr_set_adapter& operator=( const ptr_set_adapter<U,Set,CA,b>& r ) 
         {
@@ -397 +402 @@
             return *this;
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class T >
         void operator=( std::auto_ptr<T> r ) 
         {
             base_type::operator=( r );
         }
-
+#endif
         std::pair<iterator,bool> insert( key_type* x ) // strong                      
         {       
             this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
@@ -415 +421 @@
             return std::make_pair( iterator( res.first ), res.second );     
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         std::pair<iterator,bool> insert( std::auto_ptr<U> x )
         {
             return insert( x.release() );
         }
-
+#endif
         
         iterator insert( iterator where, key_type* x ) // strong
         {
@@ -434 +441 @@
             return iterator( res);
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( iterator where, std::auto_ptr<U> x )
         {
             return insert( where, x.release() );
         }
-        
+#endif
+
         template< typename InputIterator >
         void insert( InputIterator first, InputIterator last ) // basic
         {
@@ -585 +594 @@
           : base_type( r )
         { }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         explicit ptr_multiset_adapter( std::auto_ptr<PtrContainer> clone )
          : base_type( clone )
         { }
-
+#endif
         template< class U, class Set, class CA, bool b >
         ptr_multiset_adapter& operator=( const ptr_multiset_adapter<U,Set,CA,b>& r ) 
         {
@@ -597 +607 @@
             return *this;
         }
         
+#ifndef BOOST_NO_AUTO_PTR
         template< class T >
         void operator=( std::auto_ptr<T> r ) 
         {
             base_type::operator=( r ); 
         }
-
+#endif
         iterator insert( iterator before, key_type* x ) // strong  
         {
             return base_type::insert( before, x ); 
         } 
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( iterator before, std::auto_ptr<U> x )
         {
             return insert( before, x.release() );
         }
-    
+#endif
+
         iterator insert( key_type* x ) // strong                                      
         {   
             this->enforce_null_policy( x, "Null pointer in 'ptr_multiset::insert()'" );
@@ -625 +638 @@
             return iterator( res );                                             
         }
 
+#ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( std::auto_ptr<U> x )
         {
             return insert( x.release() );
         }
+#endif
     
         template< typename InputIterator >
         void insert( InputIterator first, InputIterator last ) // basic