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