|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r56346 - trunk/boost/unordered/detail
From: daniel_james_at_[hidden]
Date: 2009-09-21 17:17:20
Author: danieljames
Date: 2009-09-21 17:17:19 EDT (Mon, 21 Sep 2009)
New Revision: 56346
URL: http://svn.boost.org/trac/boost/changeset/56346
Log:
Slightly more consistent variable names. In detail 'n' is now always a node pointer.
Text files modified:
trunk/boost/unordered/detail/buckets.hpp | 12 +-
trunk/boost/unordered/detail/equivalent.hpp | 14 +-
trunk/boost/unordered/detail/fwd.hpp | 24 +++---
trunk/boost/unordered/detail/node.hpp | 28 +++---
trunk/boost/unordered/detail/table.hpp | 56 +++++++------
trunk/boost/unordered/detail/unique.hpp | 156 ++++++++++++++++++++-------------------
trunk/boost/unordered/detail/util.hpp | 35 ++++----
7 files changed, 165 insertions(+), 160 deletions(-)
Modified: trunk/boost/unordered/detail/buckets.hpp
==============================================================================
--- trunk/boost/unordered/detail/buckets.hpp (original)
+++ trunk/boost/unordered/detail/buckets.hpp 2009-09-21 17:17:19 EDT (Mon, 21 Sep 2009)
@@ -19,9 +19,9 @@
template <class A, class G>
inline BOOST_DEDUCED_TYPENAME hash_buckets<A, G>::bucket_ptr
- hash_buckets<A, G>::get_bucket(std::size_t n) const
+ hash_buckets<A, G>::get_bucket(std::size_t num) const
{
- return buckets_ + static_cast<std::ptrdiff_t>(n);
+ return buckets_ + static_cast<std::ptrdiff_t>(num);
}
template <class A, class G>
@@ -46,9 +46,9 @@
template <class A, class G>
inline BOOST_DEDUCED_TYPENAME hash_buckets<A, G>::node_ptr
- hash_buckets<A, G>::bucket_begin(std::size_t n) const
+ hash_buckets<A, G>::bucket_begin(std::size_t num) const
{
- return buckets_ ? get_bucket(n)->next_ : node_ptr();
+ return buckets_ ? get_bucket(num)->next_ : node_ptr();
}
////////////////////////////////////////////////////////////////////////////
@@ -103,9 +103,9 @@
{
std::size_t count = 0;
while(begin != end) {
- node_ptr node = begin;
+ node_ptr n = begin;
begin = begin->next_;
- delete_node(node);
+ delete_node(n);
++count;
}
return count;
Modified: trunk/boost/unordered/detail/equivalent.hpp
==============================================================================
--- trunk/boost/unordered/detail/equivalent.hpp (original)
+++ trunk/boost/unordered/detail/equivalent.hpp 2009-09-21 17:17:19 EDT (Mon, 21 Sep 2009)
@@ -177,27 +177,27 @@
#else
-#define BOOST_UNORDERED_INSERT_IMPL(z, n, _) \
+#define BOOST_UNORDERED_INSERT_IMPL(z, num_params, _) \
template <class H, class P, class A, class K> \
- template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)> \
+ template <BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)> \
BOOST_DEDUCED_TYPENAME hash_equivalent_table<H, P, A, K>::iterator_base \
hash_equivalent_table<H, P, A, K> \
- ::emplace(BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
+ ::emplace(BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
{ \
node_constructor a(*this); \
- a.construct(BOOST_UNORDERED_CALL_PARAMS(z, n)); \
+ a.construct(BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
return emplace_impl(a); \
} \
\
template <class H, class P, class A, class K> \
- template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)> \
+ template <BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)> \
BOOST_DEDUCED_TYPENAME hash_equivalent_table<H, P, A, K>::iterator_base \
hash_equivalent_table<H, P, A, K> \
::emplace_hint(iterator_base const& it, \
- BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
{ \
node_constructor a(*this); \
- a.construct(BOOST_UNORDERED_CALL_PARAMS(z, n)); \
+ a.construct(BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
return emplace_hint_impl(it, a); \
}
Modified: trunk/boost/unordered/detail/fwd.hpp
==============================================================================
--- trunk/boost/unordered/detail/fwd.hpp (original)
+++ trunk/boost/unordered/detail/fwd.hpp 2009-09-21 17:17:19 EDT (Mon, 21 Sep 2009)
@@ -50,12 +50,12 @@
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#define BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
- BOOST_PP_ENUM_PARAMS_Z(z, n, class Arg)
-#define BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
- BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, const& arg)
-#define BOOST_UNORDERED_CALL_PARAMS(z, n) \
- BOOST_PP_ENUM_PARAMS_Z(z, n, arg)
+#define BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params) \
+ BOOST_PP_ENUM_PARAMS_Z(z, num_params, class Arg)
+#define BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params) \
+ BOOST_PP_ENUM_BINARY_PARAMS_Z(z, num_params, Arg, const& arg)
+#define BOOST_UNORDERED_CALL_PARAMS(z, num_params) \
+ BOOST_PP_ENUM_PARAMS_Z(z, num_params, arg)
#endif
@@ -126,7 +126,7 @@
static inline std::size_t group_count(node_ptr ptr);
static inline void add_to_bucket(node_ptr n, bucket& b);
static inline void add_after_node(node_ptr n, node_ptr position);
- static void unlink_node(bucket& b, node_ptr node);
+ static void unlink_node(bucket& b, node_ptr n);
static void unlink_nodes(bucket& b, node_ptr begin, node_ptr end);
static void unlink_nodes(bucket& b, node_ptr end);
};
@@ -146,7 +146,7 @@
static inline std::size_t group_count(node_ptr ptr);
static inline void add_to_bucket(node_ptr n, bucket& b);
static inline void add_after_node(node_ptr n, node_ptr position);
- static void unlink_node(bucket& b, node_ptr node);
+ static void unlink_node(bucket& b, node_ptr n);
static void unlink_nodes(bucket& b, node_ptr begin, node_ptr end);
static void unlink_nodes(bucket& b, node_ptr end);
@@ -237,12 +237,12 @@
return node::get_value(node_);
}
- void increment_bucket(node_ptr node) {
- while(!node) {
+ void increment_bucket(node_ptr n) {
+ while(!n) {
++bucket_;
- node = bucket_->next_;
+ n = bucket_->next_;
}
- node_ = bucket_ == node ? node_ptr() : node;
+ node_ = bucket_ == n ? node_ptr() : n;
}
void increment() {
Modified: trunk/boost/unordered/detail/node.hpp
==============================================================================
--- trunk/boost/unordered/detail/node.hpp (original)
+++ trunk/boost/unordered/detail/node.hpp 2009-09-21 17:17:19 EDT (Mon, 21 Sep 2009)
@@ -71,9 +71,9 @@
}
template <class A>
- inline void ungrouped_node_base<A>::unlink_node(bucket& b, node_ptr node)
+ inline void ungrouped_node_base<A>::unlink_node(bucket& b, node_ptr n)
{
- unlink_nodes(b, node, node->next_);
+ unlink_nodes(b, n, n->next_);
}
////////////////////////////////////////////////////////////////////////////
@@ -144,41 +144,41 @@
}
template <class A>
- void grouped_node_base<A>::unlink_node(bucket& b, node_ptr node)
+ void grouped_node_base<A>::unlink_node(bucket& b, node_ptr n)
{
- node_ptr next = node->next_;
- node_ptr* pos = &next_group(node);
+ node_ptr next = n->next_;
+ node_ptr* pos = &next_group(n);
- if(*pos != node) {
+ if(*pos != n) {
// The node is at the beginning of a group.
// Find the previous node pointer:
pos = &b.next_;
- while(*pos != node) pos = &next_group(*pos);
+ while(*pos != n) pos = &next_group(*pos);
// Remove from group
if(BOOST_UNORDERED_BORLAND_BOOL(next) &&
- get(next).group_prev_ == node)
+ get(next).group_prev_ == n)
{
- get(next).group_prev_ = get(node).group_prev_;
+ get(next).group_prev_ = get(n).group_prev_;
}
}
else if(BOOST_UNORDERED_BORLAND_BOOL(next) &&
- get(next).group_prev_ == node)
+ get(next).group_prev_ == n)
{
// The deleted node is not at the end of the group, so
// change the link from the next node.
- get(next).group_prev_ = get(node).group_prev_;
+ get(next).group_prev_ = get(n).group_prev_;
}
else {
// The deleted node is at the end of the group, so the
// first node in the group is pointing to it.
// Find that to change its pointer.
- node_ptr x = get(node).group_prev_;
- while(get(x).group_prev_ != node) {
+ node_ptr x = get(n).group_prev_;
+ while(get(x).group_prev_ != n) {
x = get(x).group_prev_;
}
- get(x).group_prev_ = get(node).group_prev_;
+ get(x).group_prev_ = get(n).group_prev_;
}
*pos = next;
}
Modified: trunk/boost/unordered/detail/table.hpp
==============================================================================
--- trunk/boost/unordered/detail/table.hpp (original)
+++ trunk/boost/unordered/detail/table.hpp 2009-09-21 17:17:19 EDT (Mon, 21 Sep 2009)
@@ -116,7 +116,7 @@
// no throw
template <class H, class P, class A, class G, class K>
inline std::size_t hash_table<H, P, A, G, K>::min_buckets_for_size(
- std::size_t n) const
+ std::size_t size) const
{
BOOST_ASSERT(this->mlf_ != 0);
@@ -128,7 +128,7 @@
//
// Or from rehash post-condition:
// count > size / mlf_
- return next_prime(double_to_size_t(floor(n / (double) mlf_)) + 1);
+ return next_prime(double_to_size_t(floor(size / (double) mlf_)) + 1);
}
////////////////////////////////////////////////////////////////////////////
@@ -199,9 +199,9 @@
// Constructors
template <class H, class P, class A, class G, class K>
- hash_table<H, P, A, G, K>::hash_table(std::size_t n,
+ hash_table<H, P, A, G, K>::hash_table(std::size_t num_buckets,
hasher const& hf, key_equal const& eq, node_allocator const& a)
- : buckets(a, next_prime(n)),
+ : buckets(a, next_prime(num_buckets)),
base(hf, eq),
size_(),
mlf_(1.0f),
@@ -404,24 +404,26 @@
// basic exception safety
template <class H, class P, class A, class G, class K>
- inline void hash_table<H, P, A, G, K>::create_for_insert(std::size_t n)
+ inline void hash_table<H, P, A, G, K>::create_for_insert(std::size_t size)
{
- if(n > this->bucket_count_)
- this->bucket_count_ = this->min_buckets_for_size(n);
+ // TODO: Write a test to detect this bug:
+ if(size > this->bucket_count_)
+ this->bucket_count_ = this->min_buckets_for_size(size);
this->create_buckets();
this->init_buckets();
}
// basic exception safety
template <class H, class P, class A, class G, class K>
- inline bool hash_table<H, P, A, G, K>::reserve_for_insert(std::size_t n)
+ inline bool hash_table<H, P, A, G, K>::reserve_for_insert(std::size_t size)
{
- if(n >= max_load_) {
+ if(size >= max_load_) {
std::size_t s = this->size_;
s = s + (s >> 1);
- n = this->min_buckets_for_size(s > n ? s : n);
- if(n != this->bucket_count_) {
- rehash_impl(n);
+ std::size_t num_buckets
+ = this->min_buckets_for_size(s > size ? s : size);
+ if(num_buckets != this->bucket_count_) {
+ rehash_impl(num_buckets);
return true;
}
}
@@ -433,24 +435,24 @@
// strong otherwise.
// TODO: Should this always create buckets?
template <class H, class P, class A, class G, class K>
- inline void hash_table<H, P, A, G, K>
- ::rehash(std::size_t n)
+ inline void hash_table<H, P, A, G, K>::rehash(std::size_t min_buckets)
{
using namespace std;
if(!this->buckets_) {
- this->bucket_count_ = next_prime(n);
+ this->bucket_count_ = next_prime(min_buckets);
this->create_buckets();
this->init_buckets();
}
- else if(n != this->bucket_count_) {
+ // TODO: Another bug:
+ else if(min_buckets != this->bucket_count_) {
// no throw:
// TODO: Needlessly calling next_prime twice.
std::size_t min_size = this->min_buckets_for_size(this->size_);
- n = next_prime(n);
- n = min_size > n ? min_size : n;
+ min_buckets = next_prime(min_buckets);
+ min_buckets = min_size > min_buckets ? min_size : min_buckets;
- rehash_impl(n);
+ rehash_impl(min_buckets);
}
}
@@ -461,13 +463,13 @@
template <class H, class P, class A, class G, class K>
void hash_table<H, P, A, G, K>
- ::rehash_impl(std::size_t n)
+ ::rehash_impl(std::size_t num_buckets)
{
hasher const& hf = this->hash_function();
std::size_t size = this->size_;
bucket_ptr end = this->get_bucket(this->bucket_count_);
- buckets dst(this->node_alloc(), n);
+ buckets dst(this->node_alloc(), num_buckets);
dst.create_buckets();
buckets src(this->node_alloc(), this->bucket_count_);
@@ -726,18 +728,18 @@
template <class H, class P, class A, class G, class K>
BOOST_DEDUCED_TYPENAME hash_table<H, P, A, G, K>::iterator_base
hash_table<H, P, A, G, K>::emplace_empty_impl_with_node(
- node_constructor& a, std::size_t n)
+ node_constructor& a, std::size_t size)
{
key_type const& k = get_key(a.value());
std::size_t hash_value = this->hash_function()(k);
- if(this->buckets_) this->reserve_for_insert(n);
- else this->create_for_insert(n);
+ if(this->buckets_) this->reserve_for_insert(size);
+ else this->create_for_insert(size);
bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
- node_ptr node = a.release();
- node::add_to_bucket(node, *bucket);
+ node_ptr n = a.release();
+ node::add_to_bucket(n, *bucket);
++this->size_;
this->cached_begin_bucket_ = bucket;
- return iterator_base(bucket, node);
+ return iterator_base(bucket, n);
}
}}
Modified: trunk/boost/unordered/detail/unique.hpp
==============================================================================
--- trunk/boost/unordered/detail/unique.hpp (original)
+++ trunk/boost/unordered/detail/unique.hpp 2009-09-21 17:17:19 EDT (Mon, 21 Sep 2009)
@@ -191,56 +191,58 @@
#else
-#define BOOST_UNORDERED_INSERT_IMPL(z, n, _) \
- template <class H, class P, class A, class K> \
- template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)> \
- inline BOOST_DEDUCED_TYPENAME \
- hash_unique_table<H, P, A, K>::emplace_return \
- hash_unique_table<H, P, A, K>::emplace_impl( \
- key_type const& k, \
- BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
- { \
- std::size_t hash_value = this->hash_function()(k); \
- bucket_ptr bucket \
- = this->bucket_ptr_from_hash(hash_value); \
- node_ptr pos = find_iterator(bucket, k); \
- \
- if (BOOST_UNORDERED_BORLAND_BOOL(pos)) { \
- return emplace_return(iterator_base(bucket, pos), false); \
- } else { \
- node_constructor a(*this); \
- a.construct(BOOST_UNORDERED_CALL_PARAMS(z, n)); \
- \
- if(this->reserve_for_insert(this->size_ + 1)) \
- bucket = this->bucket_ptr_from_hash(hash_value); \
- \
- return emplace_return(iterator_base(bucket, \
- add_node(a, bucket)), true); \
- } \
- } \
- \
- template <class H, class P, class A, class K> \
- template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)> \
- inline BOOST_DEDUCED_TYPENAME \
- hash_unique_table<H, P, A, K>::emplace_return \
- hash_unique_table<H, P, A, K>:: \
- emplace_impl(no_key, BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
- { \
- node_constructor a(*this); \
- a.construct(BOOST_UNORDERED_CALL_PARAMS(z, n)); \
- return emplace_impl_with_node(a); \
- } \
- \
- template <class H, class P, class A, class K> \
- template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)> \
- inline BOOST_DEDUCED_TYPENAME \
- hash_unique_table<H, P, A, K>::emplace_return \
- hash_unique_table<H, P, A, K>:: \
- emplace_empty_impl(BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
- { \
- node_constructor a(*this); \
- a.construct(BOOST_UNORDERED_CALL_PARAMS(z, n)); \
- return emplace_return(this->emplace_empty_impl_with_node(a, 1), true); \
+#define BOOST_UNORDERED_INSERT_IMPL(z, num_params, _) \
+ template <class H, class P, class A, class K> \
+ template <BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)> \
+ inline BOOST_DEDUCED_TYPENAME \
+ hash_unique_table<H, P, A, K>::emplace_return \
+ hash_unique_table<H, P, A, K>::emplace_impl( \
+ key_type const& k, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
+ { \
+ std::size_t hash_value = this->hash_function()(k); \
+ bucket_ptr bucket \
+ = this->bucket_ptr_from_hash(hash_value); \
+ node_ptr pos = find_iterator(bucket, k); \
+ \
+ if (BOOST_UNORDERED_BORLAND_BOOL(pos)) { \
+ return emplace_return(iterator_base(bucket, pos), false); \
+ } else { \
+ node_constructor a(*this); \
+ a.construct(BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
+ \
+ if(this->reserve_for_insert(this->size_ + 1)) \
+ bucket = this->bucket_ptr_from_hash(hash_value); \
+ \
+ return emplace_return(iterator_base(bucket, \
+ add_node(a, bucket)), true); \
+ } \
+ } \
+ \
+ template <class H, class P, class A, class K> \
+ template <BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)> \
+ inline BOOST_DEDUCED_TYPENAME \
+ hash_unique_table<H, P, A, K>::emplace_return \
+ hash_unique_table<H, P, A, K>:: \
+ emplace_impl(no_key, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
+ { \
+ node_constructor a(*this); \
+ a.construct(BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
+ return emplace_impl_with_node(a); \
+ } \
+ \
+ template <class H, class P, class A, class K> \
+ template <BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)> \
+ inline BOOST_DEDUCED_TYPENAME \
+ hash_unique_table<H, P, A, K>::emplace_return \
+ hash_unique_table<H, P, A, K>:: \
+ emplace_empty_impl( \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
+ { \
+ node_constructor a(*this); \
+ a.construct(BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
+ return emplace_return(this->emplace_empty_impl_with_node(a, 1), true); \
}
BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
@@ -312,33 +314,33 @@
emplace_empty_impl(arg0).first;
}
-#define BOOST_UNORDERED_INSERT_IMPL(z, n, _) \
- template <class H, class P, class A, class K> \
- template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)> \
- BOOST_DEDUCED_TYPENAME hash_unique_table<H, P, A, K>::emplace_return \
- hash_unique_table<H, P, A, K>::emplace( \
- BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
- { \
- return this->size_ ? \
- emplace_impl(extractor::extract(arg0, arg1), \
- BOOST_UNORDERED_CALL_PARAMS(z, n)) : \
- emplace_empty_impl( \
- BOOST_UNORDERED_CALL_PARAMS(z, n)); \
- } \
- \
- template <class H, class P, class A, class K> \
- template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)> \
- BOOST_DEDUCED_TYPENAME hash_unique_table<H, P, A, K>::iterator_base \
- hash_unique_table<H, P, A, K>:: \
- emplace_hint(iterator_base const& it, \
- BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
- { \
- return this->size_ ? \
- emplace_impl(extractor::extract(arg0, arg1), \
- BOOST_UNORDERED_CALL_PARAMS(z, n)) : \
- emplace_empty_impl( \
- BOOST_UNORDERED_CALL_PARAMS(z, n)); \
- } \
+#define BOOST_UNORDERED_INSERT_IMPL(z, num_params, _) \
+ template <class H, class P, class A, class K> \
+ template <BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)> \
+ BOOST_DEDUCED_TYPENAME hash_unique_table<H, P, A, K>::emplace_return \
+ hash_unique_table<H, P, A, K>::emplace( \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
+ { \
+ return this->size_ ? \
+ emplace_impl(extractor::extract(arg0, arg1), \
+ BOOST_UNORDERED_CALL_PARAMS(z, num_params)) : \
+ emplace_empty_impl( \
+ BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
+ } \
+ \
+ template <class H, class P, class A, class K> \
+ template <BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params)> \
+ BOOST_DEDUCED_TYPENAME hash_unique_table<H, P, A, K>::iterator_base \
+ hash_unique_table<H, P, A, K>:: \
+ emplace_hint(iterator_base const& it, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
+ { \
+ return this->size_ ? \
+ emplace_impl(extractor::extract(arg0, arg1), \
+ BOOST_UNORDERED_CALL_PARAMS(z, num_params)) : \
+ emplace_empty_impl( \
+ BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
+ } \
BOOST_PP_REPEAT_FROM_TO(2, BOOST_UNORDERED_EMPLACE_LIMIT,
BOOST_UNORDERED_INSERT_IMPL, _)
Modified: trunk/boost/unordered/detail/util.hpp
==============================================================================
--- trunk/boost/unordered/detail/util.hpp (original)
+++ trunk/boost/unordered/detail/util.hpp 2009-09-21 17:17:19 EDT (Mon, 21 Sep 2009)
@@ -61,24 +61,24 @@
typedef prime_list_template<std::size_t> prime_list;
// no throw
- inline std::size_t next_prime(std::size_t n) {
+ inline std::size_t next_prime(std::size_t num) {
std::size_t const* const prime_list_begin = prime_list::value;
std::size_t const* const prime_list_end = prime_list_begin +
prime_list::length;
std::size_t const* bound =
- std::lower_bound(prime_list_begin, prime_list_end, n);
+ std::lower_bound(prime_list_begin, prime_list_end, num);
if(bound == prime_list_end)
bound--;
return *bound;
}
// no throw
- inline std::size_t prev_prime(std::size_t n) {
+ inline std::size_t prev_prime(std::size_t num) {
std::size_t const* const prime_list_begin = prime_list::value;
std::size_t const* const prime_list_end = prime_list_begin +
prime_list::length;
std::size_t const* bound =
- std::upper_bound(prime_list_begin,prime_list_end, n);
+ std::upper_bound(prime_list_begin,prime_list_end, num);
if(bound != prime_list_begin)
bound--;
return *bound;
@@ -129,9 +129,10 @@
template <class I>
inline std::size_t initial_size(I i, I j,
- std::size_t n = boost::unordered_detail::default_bucket_count)
+ std::size_t num_buckets = boost::unordered_detail::default_bucket_count)
{
- return (std::max)(static_cast<std::size_t>(insert_size(i, j)) + 1, n);
+ return (std::max)(static_cast<std::size_t>(insert_size(i, j)) + 1,
+ num_buckets);
}
////////////////////////////////////////////////////////////////////////////
@@ -158,29 +159,29 @@
#else
-#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, n, _) \
+#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, num_params, _) \
template < \
class T, \
- BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params) \
> \
inline void construct_impl( \
T*, void* address, \
- BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params) \
) \
{ \
new(address) T( \
- BOOST_UNORDERED_CALL_PARAMS(z, n)); \
+ BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
} \
\
template <class First, class Second, class Key, \
- BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params) \
> \
inline void construct_impl( \
std::pair<First, Second>*, void* address, \
- Key const& k, BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
+ Key const& k, BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
{ \
new(address) std::pair<First, Second>(k, \
- Second(BOOST_UNORDERED_CALL_PARAMS(z, n))); \
+ Second(BOOST_UNORDERED_CALL_PARAMS(z, num_params))); \
}
BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
@@ -230,18 +231,18 @@
}
#else
-#define BOOST_UNORDERED_CONSTRUCT(z, n, _) \
+#define BOOST_UNORDERED_CONSTRUCT(z, num_params, _) \
template < \
- BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params) \
> \
void construct( \
- BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params) \
) \
{ \
construct_preamble(); \
construct_impl( \
(value_type*) 0, node_->address(), \
- BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ BOOST_UNORDERED_CALL_PARAMS(z, num_params) \
); \
value_constructed_ = true; \
}
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk