Ticket #9894: 0001-ptr_container-fix-GCC-Wshadow-warnings.patch

include/boost/ptr_container/detail/move.hpp

@@ -20 +20 @@
 template<typename Ptr>
 class move_source {
 public:
-    move_source(Ptr& ptr) : ptr_(ptr) {}
+    move_source(Ptr& _ptr) : ptr_(_ptr) {}
     Ptr& ptr() const { return ptr_; }
 private:
     Ptr& ptr_;

include/boost/ptr_container/detail/reversible_ptr_container.hpp

@@ -278 +278 @@
 
     private:
         template< class ForwardIterator >
-        ForwardIterator advance( ForwardIterator begin, size_type n ) 
+        ForwardIterator advance( ForwardIterator begin_, size_type n )
         {
-            ForwardIterator iter = begin;
+            ForwardIterator iter = begin_;
             std::advance( iter, n );
             return iter;
         }        

include/boost/ptr_container/detail/static_move_ptr.hpp

@@ -151 +151 @@
     deleter_const_reference get_deleter() const { return impl_.second(); }
 private:
     template<typename TT, typename DD>
-    void check(const static_move_ptr<TT, DD>& ptr)
+    void check(const static_move_ptr<TT, DD>&)
         {
             typedef move_ptrs::is_smart_ptr_convertible<TT, T> convertible;
             BOOST_STATIC_ASSERT(convertible::value);

include/boost/ptr_container/exception.hpp

@@ -24 +24 @@
     {
         const char* what_;
     public:
-        bad_ptr_container_operation( const char* what ) : what_( what )
+        bad_ptr_container_operation( const char* _what ) : what_( _what )
         { }
         
         virtual const char* what() const throw()
@@ -38 +38 @@
     class bad_index : public bad_ptr_container_operation
     {
     public:
-        bad_index( const char* what ) : bad_ptr_container_operation( what )
+        bad_index( const char* _what ) : bad_ptr_container_operation( _what )
         { }
     };
 

include/boost/ptr_container/ptr_sequence_adapter.hpp

@@ -476 +476 @@
     public: // C-array support
     
         void transfer( iterator before, value_type* from, 
-                       size_type size, bool delete_from = true ) // strong 
+                       size_type size_, bool delete_from = true ) // strong
         {
             BOOST_ASSERT( from != 0 );
             if( delete_from )
             {
                 BOOST_DEDUCED_TYPENAME base_type::scoped_deleter 
-                    deleter( from, size );                                // nothrow
-                this->base().insert( before.base(), from, from + size );  // strong
+                    deleter( from, size_ );                                // nothrow
+                this->base().insert( before.base(), from, from + size_ );  // strong
                 deleter.release();                                        // nothrow
             }
             else
             {
-                this->base().insert( before.base(), from, from + size ); // strong
+                this->base().insert( before.base(), from, from + size_ ); // strong
             }
         }
 
@@ -510 +510 @@
 
     public: // resize
 
-        void resize( size_type size ) // basic
+        void resize( size_type size_ ) // basic
         {
             size_type old_size = this->size();
-            if( old_size > size )
+            if( old_size > size_ )
             {
-                this->erase( boost::next( this->begin(), size ), this->end() );  
+                this->erase( boost::next( this->begin(), size_ ), this->end() );
             }
-            else if( size > old_size )
+            else if( size_ > old_size )
             {
-                for( ; old_size != size; ++old_size )
+                for( ; old_size != size_; ++old_size )
                     this->push_back( new BOOST_DEDUCED_TYPENAME 
                                      boost::remove_pointer<value_type>::type() ); 
             }
 
-            BOOST_ASSERT( this->size() == size );
+            BOOST_ASSERT( this->size() == size_ );
         }
 
-        void resize( size_type size, value_type to_clone ) // basic
+        void resize( size_type size_, value_type to_clone ) // basic
         {
             size_type old_size = this->size();
-            if( old_size > size )
+            if( old_size > size_ )
             {
-                this->erase( boost::next( this->begin(), size ), this->end() );  
+                this->erase( boost::next( this->begin(), size_ ), this->end() );
             }
-            else if( size > old_size )
+            else if( size_ > old_size )
             {
-                for( ; old_size != size; ++old_size )
+                for( ; old_size != size_; ++old_size )
                     this->push_back( this->null_policy_allocate_clone( to_clone ) ); 
             }
 
-            BOOST_ASSERT( this->size() == size );        
+            BOOST_ASSERT( this->size() == size_ );
         }
 
-        void rresize( size_type size ) // basic
+        void rresize( size_type size_ ) // basic
         {
             size_type old_size = this->size();
-            if( old_size > size )
+            if( old_size > size_ )
             {
                 this->erase( this->begin(), 
-                             boost::next( this->begin(), old_size - size ) );  
+                             boost::next( this->begin(), old_size - size_ ) );
             }
-            else if( size > old_size )
+            else if( size_ > old_size )
             {
-                for( ; old_size != size; ++old_size )
+                for( ; old_size != size_; ++old_size )
                     this->push_front( new BOOST_DEDUCED_TYPENAME 
                                       boost::remove_pointer<value_type>::type() ); 
             }
 
-            BOOST_ASSERT( this->size() == size );
+            BOOST_ASSERT( this->size() == size_ );
         }
 
-        void rresize( size_type size, value_type to_clone ) // basic
+        void rresize( size_type size_, value_type to_clone ) // basic
         {
             size_type old_size = this->size();
-            if( old_size > size )
+            if( old_size > size_ )
             {
                 this->erase( this->begin(), 
-                             boost::next( this->begin(), old_size - size ) );  
+                             boost::next( this->begin(), old_size - size_ ) );
             }
-            else if( size > old_size )
+            else if( size_ > old_size )
             {
-                for( ; old_size != size; ++old_size )
+                for( ; old_size != size_; ++old_size )
                     this->push_front( this->null_policy_allocate_clone( to_clone ) ); 
             }
 
-            BOOST_ASSERT( this->size() == size );
+            BOOST_ASSERT( this->size() == size_ );
         }           
                 
     public: // algorithms