external/boost/boost.ptr_container.Wshadow.warnings.patch

   1 --- misc/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp      2009-11-01 12:07:12.000000000 +0100
   2 +++ misc/build/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp        2011-02-04 16:39:19.000000000 +0100
   3 @@ -476,19 +476,19 @@
   4      public: // C-array support
   5
   6          void transfer( iterator before, value_type* from,
   7 -                       size_type size, bool delete_from = true ) // strong
   8 +                       size_type size_, bool delete_from = true ) // strong
   9          {
  10              BOOST_ASSERT( from != 0 );
  11              if( delete_from )
  12              {
  13                  BOOST_DEDUCED_TYPENAME base_type::scoped_deleter
  14 -                    deleter( from, size );                                // nothrow
  15 -                this->base().insert( before.base(), from, from + size );  // strong
  16 +                    deleter( from, size_ );                                // nothrow
  17 +                this->base().insert( before.base(), from, from + size_ );  // strong
  18                  deleter.release();                                        // nothrow
  19              }
  20              else
  21              {
  22 -                this->base().insert( before.base(), from, from + size ); // strong
  23 +                this->base().insert( before.base(), from, from + size_ ); // strong
  24              }
  25          }
  26
  27 --- misc/boost_1_44_0/boost/ptr_container/exception.hpp 2011-02-05 09:42:56.074932485 +0000
  28 +++ misc/build/boost_1_44_0/boost/ptr_container/exception.hpp   2011-02-05 09:43:00.350931536 +0000
  29 @@ -24,7 +24,7 @@
  30      {
  31          const char* what_;
  32      public:
  33 -        bad_ptr_container_operation( const char* what ) : what_( what )
  34 +        bad_ptr_container_operation( const char* _what ) : what_( _what )
  35          { }
  36
  37          virtual const char* what() const throw()
  38 @@ -38,7 +38,7 @@
  39      class bad_index : public bad_ptr_container_operation
  40      {
  41      public:
  42 -        bad_index( const char* what ) : bad_ptr_container_operation( what )
  43 +        bad_index( const char* _what ) : bad_ptr_container_operation( _what )
  44          { }
  45      };
  46
  47 --- misc/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp   2011-02-05 09:49:30.373931807 +0000
  48 +++ misc/build/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp     2011-02-05 09:49:34.804931932 +0000
  49 @@ -278,9 +278,9 @@
  50
  51      private:
  52          template< class ForwardIterator >
  53 -        ForwardIterator advance( ForwardIterator begin, size_type n )
  54 +        ForwardIterator advance( ForwardIterator begin_, size_type n )
  55          {
  56 -            ForwardIterator iter = begin;
  57 +            ForwardIterator iter = begin_;
  58              std::advance( iter, n );
  59              return iter;
  60          }
  61 --- misc/boost_1_44_0/boost/ptr_container/detail/move.hpp       2011-02-05 10:01:21.156931884 +0000
  62 +++ misc/build/boost_1_44_0/boost/ptr_container/detail/move.hpp 2011-02-05 10:01:14.160931007 +0000
  63 @@ -20,7 +20,7 @@
  64  template<typename Ptr>
  65  class move_source {
  66  public:
  67 -    move_source(Ptr& ptr) : ptr_(ptr) {}
  68 +    move_source(Ptr& _ptr) : ptr_(_ptr) {}
  69      Ptr& ptr() const { return ptr_; }
  70  private:
  71      Ptr& ptr_;
  72 --- misc/boost_1_44_0/boost/ptr_container/detail/static_move_ptr.hpp    2011-02-05 09:55:44.846931338 +0000
  73 +++ misc/build/boost_1_44_0/boost/ptr_container/detail/static_move_ptr.hpp      2011-02-05 09:56:42.760931701 +0000
  74 @@ -151,7 +151,7 @@
  75      deleter_const_reference get_deleter() const { return impl_.second(); }
  76  private:
  77      template<typename TT, typename DD>
  78 -    void check(const static_move_ptr<TT, DD>& ptr)
  79 +    void check(const static_move_ptr<TT, DD>&)
  80          {
  81              typedef move_ptrs::is_smart_ptr_convertible<TT, T> convertible;
  82              BOOST_STATIC_ASSERT(convertible::value);
  83 --- misc/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp      2011-02-09 08:49:00.416529470 +0000
  84 +++ misc/build/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp        2011-02-09 08:50:44.607653864 +0000
  85 @@ -510,72 +510,72 @@
  86
  87      public: // resize
  88
  89 -        void resize( size_type size ) // basic
  90 +        void resize( size_type size_ ) // basic
  91          {
  92              size_type old_size = this->size();
  93 -            if( old_size > size )
  94 +            if( old_size > size_ )
  95              {
  96 -                this->erase( boost::next( this->begin(), size ), this->end() );
  97 +                this->erase( boost::next( this->begin(), size_ ), this->end() );
  98              }
  99 -            else if( size > old_size )
 100 +            else if( size_ > old_size )
 101              {
 102 -                for( ; old_size != size; ++old_size )
 103 +                for( ; old_size != size_; ++old_size )
 104                      this->push_back( new BOOST_DEDUCED_TYPENAME
 105                                       boost::remove_pointer<value_type>::type() );
 106              }
 107
 108 -            BOOST_ASSERT( this->size() == size );
 109 +            BOOST_ASSERT( this->size() == size_ );
 110          }
 111
 112 -        void resize( size_type size, value_type to_clone ) // basic
 113 +        void resize( size_type size_, value_type to_clone ) // basic
 114          {
 115              size_type old_size = this->size();
 116 -            if( old_size > size )
 117 +            if( old_size > size_ )
 118              {
 119 -                this->erase( boost::next( this->begin(), size ), this->end() );
 120 +                this->erase( boost::next( this->begin(), size_ ), this->end() );
 121              }
 122 -            else if( size > old_size )
 123 +            else if( size_ > old_size )
 124              {
 125 -                for( ; old_size != size; ++old_size )
 126 +                for( ; old_size != size_; ++old_size )
 127                      this->push_back( this->null_policy_allocate_clone( to_clone ) );
 128              }
 129
 130 -            BOOST_ASSERT( this->size() == size );
 131 +            BOOST_ASSERT( this->size() == size_ );
 132          }
 133
 134 -        void rresize( size_type size ) // basic
 135 +        void rresize( size_type size_ ) // basic
 136          {
 137              size_type old_size = this->size();
 138 -            if( old_size > size )
 139 +            if( old_size > size_ )
 140              {
 141                  this->erase( this->begin(),
 142 -                             boost::next( this->begin(), old_size - size ) );
 143 +                             boost::next( this->begin(), old_size - size_ ) );
 144              }
 145 -            else if( size > old_size )
 146 +            else if( size_ > old_size )
 147              {
 148 -                for( ; old_size != size; ++old_size )
 149 +                for( ; old_size != size_; ++old_size )
 150                      this->push_front( new BOOST_DEDUCED_TYPENAME
 151                                        boost::remove_pointer<value_type>::type() );
 152              }
 153
 154 -            BOOST_ASSERT( this->size() == size );
 155 +            BOOST_ASSERT( this->size() == size_ );
 156          }
 157
 158 -        void rresize( size_type size, value_type to_clone ) // basic
 159 +        void rresize( size_type size_, value_type to_clone ) // basic
 160          {
 161              size_type old_size = this->size();
 162 -            if( old_size > size )
 163 +            if( old_size > size_ )
 164              {
 165                  this->erase( this->begin(),
 166 -                             boost::next( this->begin(), old_size - size ) );
 167 +                             boost::next( this->begin(), old_size - size_ ) );
 168              }
 169 -            else if( size > old_size )
 170 +            else if( size_ > old_size )
 171              {
 172 -                for( ; old_size != size; ++old_size )
 173 +                for( ; old_size != size_; ++old_size )
 174                      this->push_front( this->null_policy_allocate_clone( to_clone ) );
 175              }
 176
 177 -            BOOST_ASSERT( this->size() == size );
 178 +            BOOST_ASSERT( this->size() == size_ );
 179          }
 180
 181      public: // algorithms