external/boost/boost.unordered.Wshadow.warnings.patch

   1 --- foo/foo/foo/boost/unordered/detail/equivalent.hpp
   2 +++ foo/foo/foo/boost/unordered/detail/equivalent.hpp
   3 @@ -536,9 +536,9 @@
   4              node_pointer first_node = static_cast<node_pointer>(prev->next_);
   5              link_pointer end = first_node->group_prev_->next_;
   6
   7 -            std::size_t count = this->delete_nodes(prev, end);
   8 +            std::size_t count_lcl = this->delete_nodes(prev, end);
   9              this->fix_bucket(bucket_index, prev);
  10 -            return count;
  11 +            return count_lcl;
  12          }
  13
  14          iterator erase(c_iterator r)
  15 @@ -557,21 +557,21 @@
  16              return iterator(r2.node_);
  17          }
  18
  19 -        link_pointer erase_nodes(node_pointer begin, node_pointer end)
  20 +        link_pointer erase_nodes(node_pointer begin_arg, node_pointer end)
  21          {
  22 -            std::size_t bucket_index = this->hash_to_bucket(begin->hash_);
  23 +            std::size_t bucket_index = this->hash_to_bucket(begin_arg->hash_);
  24
  25 -            // Split the groups containing 'begin' and 'end'.
  26 -            // And get the pointer to the node before begin while
  27 +            // Split the groups containing 'begin_arg' and 'end.'
  28 +            // And get the pointer to the node before begin_arg while
  29              // we're at it.
  30 -            link_pointer prev = split_groups(begin, end);
  31 +            link_pointer prev = split_groups(begin_arg, end);
  32
  33 -            // If we don't have a 'prev' it means that begin is at the
  34 +            // If we don't have a 'prev' it means that begin_arg is at the
  35              // beginning of a block, so search through the blocks in the
  36              // same bucket.
  37              if (!prev) {
  38                  prev = this->get_previous_start(bucket_index);
  39 -                while (prev->next_ != begin)
  40 +                while (prev->next_ != begin_arg)
  41                      prev = static_cast<node_pointer>(prev->next_)->group_prev_;
  42              }
  43
  44 @@ -586,27 +586,27 @@
  45              return prev;
  46          }
  47
  48 -        static link_pointer split_groups(node_pointer begin, node_pointer end)
  49 +        static link_pointer split_groups(node_pointer begin_arg, node_pointer end)
  50          {
  51 -            node_pointer prev = begin->group_prev_;
  52 -            if (prev->next_ != begin) prev = node_pointer();
  53 +            node_pointer prev = begin_arg->group_prev_;
  54 +            if (prev->next_ != begin_arg) prev = node_pointer();
  55
  56              if (end) {
  57                  node_pointer first = end;
  58 -                while (first != begin && first->group_prev_->next_ == first) {
  59 +                while (first != begin_arg && first->group_prev_->next_ == first) {
  60                      first = first->group_prev_;
  61                  }
  62
  63                  boost::swap(first->group_prev_, end->group_prev_);
  64 -                if (first == begin) return prev;
  65 +                if (first == begin_arg) return prev;
  66              }
  67
  68              if (prev) {
  69                  node_pointer first = prev;
  70                  while (first->group_prev_->next_ == first) {
  71                      first = first->group_prev_;
  72                  }
  73 -                boost::swap(first->group_prev_, begin->group_prev_);
  74 +                boost::swap(first->group_prev_, begin_arg->group_prev_);
  75              }
  76
  77              return prev;
  78 --- foo/foo/foo/boost/unordered/detail/table.hpp
  79 +++ foo/foo/foo/boost/unordered/detail/table.hpp
  80 @@ -256,9 +256,9 @@
  81              return prev ? iterator(prev->next_) : iterator();
  82          }
  83
  84 -        std::size_t hash_to_bucket(std::size_t hash) const
  85 +        std::size_t hash_to_bucket(std::size_t hash_arg) const
  86          {
  87 -            return policy::to_bucket(bucket_count_, hash);
  88 +            return policy::to_bucket(bucket_count_, hash_arg);
  89          }
  90
  91          float load_factor() const
  92 @@ -655,8 +655,8 @@
  93              // assign_nodes takes ownership of the container's elements,
  94              // assigning to them if possible, and deleting any that are
  95              // left over.
  96 -            assign_nodes<table> assign(*this);
  97 -            table_impl::fill_buckets(x.begin(), *this, assign);
  98 +            assign_nodes<table> assign_lcl(*this);
  99 +            table_impl::fill_buckets(x.begin(), *this, assign_lcl);
 100          }
 101
 102          void assign(table const& x, true_type)
 103 @@ -732,9 +732,9 @@
 104                  // move_assign_nodes takes ownership of the container's
 105                  // elements, assigning to them if possible, and deleting
 106                  // any that are left over.
 107 -                move_assign_nodes<table> assign(*this);
 108 +                move_assign_nodes<table> assign_lcl(*this);
 109                  node_holder<node_allocator> nodes(x);
 110 -                table_impl::fill_buckets(nodes.begin(), *this, assign);
 111 +                table_impl::fill_buckets(nodes.begin(), *this, assign_lcl);
 112              }
 113          }
 114
 115 --- foo/foo/foo/boost/unordered/detail/unique.hpp
 116 +++ foo/foo/foo/boost/unordered/detail/unique.hpp
 117 @@ -531,9 +531,9 @@
 118
 119              link_pointer end = static_cast<node_pointer>(prev->next_)->next_;
 120
 121 -            std::size_t count = this->delete_nodes(prev, end);
 122 +            std::size_t count_lcl = this->delete_nodes(prev, end);
 123              this->fix_bucket(bucket_index, prev);
 124 -            return count;
 125 +            return count_lcl;
 126          }
 127
 128          iterator erase(c_iterator r)
 129 @@ -552,13 +552,13 @@
 130              return iterator(r2.node_);
 131          }
 132
 133 -        void erase_nodes(node_pointer begin, node_pointer end)
 134 +        void erase_nodes(node_pointer begin_arg, node_pointer end)
 135          {
 136 -            std::size_t bucket_index = this->hash_to_bucket(begin->hash_);
 137 +            std::size_t bucket_index = this->hash_to_bucket(begin_arg->hash_);
 138
 139 -            // Find the node before begin.
 140 +            // Find the node before begin_arg.
 141              link_pointer prev = this->get_previous_start(bucket_index);
 142 -            while(prev->next_ != begin) prev = prev->next_;
 143 +            while(prev->next_ != begin_arg) prev = prev->next_;
 144
 145              // Delete the nodes.
 146              do {