diff options
Diffstat (limited to 'boost/unordered/detail/table.hpp')
| -rw-r--r-- | boost/unordered/detail/table.hpp | 731 |
1 files changed, 575 insertions, 156 deletions
diff --git a/boost/unordered/detail/table.hpp b/boost/unordered/detail/table.hpp index cbf6219554..2bb5d45003 100644 --- a/boost/unordered/detail/table.hpp +++ b/boost/unordered/detail/table.hpp @@ -7,12 +7,34 @@ #ifndef BOOST_UNORDERED_DETAIL_ALL_HPP_INCLUDED #define BOOST_UNORDERED_DETAIL_ALL_HPP_INCLUDED +#include <boost/config.hpp> +#if defined(BOOST_HAS_PRAGMA_ONCE) +#pragma once +#endif + #include <boost/unordered/detail/buckets.hpp> #include <boost/unordered/detail/util.hpp> #include <boost/type_traits/aligned_storage.hpp> #include <boost/type_traits/alignment_of.hpp> #include <cmath> +#if defined(BOOST_MSVC) +#pragma warning(push) +#pragma warning(disable:4127) // conditional expression is constant +#endif + +#if defined(BOOST_UNORDERED_DEPRECATED_EQUALITY) + +#if defined(__EDG__) +#elif defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__) +#pragma message("Warning: BOOST_UNORDERED_DEPRECATED_EQUALITY is no longer supported.") +#elif defined(__GNUC__) || defined(__HP_aCC) || \ + defined(__SUNPRO_CC) || defined(__IBMCPP__) +#warning "BOOST_UNORDERED_DEPRECATED_EQUALITY is no longer supported." +#endif + +#endif + namespace boost { namespace unordered { namespace detail { //////////////////////////////////////////////////////////////////////////// @@ -37,6 +59,10 @@ namespace boost { namespace unordered { namespace detail { sizeof(value_type), boost::alignment_of<value_type>::value>::type data_; + value_base() : + data_() + {} + void* address() { return this; } @@ -54,13 +80,72 @@ namespace boost { namespace unordered { namespace detail { value_base& operator=(value_base const&); }; + template <typename NodeAlloc> + struct copy_nodes + { + typedef boost::unordered::detail::allocator_traits<NodeAlloc> + node_allocator_traits; + + node_constructor<NodeAlloc> constructor; + + explicit copy_nodes(NodeAlloc& a) : constructor(a) {} + + typename node_allocator_traits::pointer create( + typename node_allocator_traits::value_type::value_type const& v) + { + constructor.construct_with_value2(v); + return constructor.release(); + } + }; + + template <typename NodeAlloc> + struct move_nodes + { + typedef boost::unordered::detail::allocator_traits<NodeAlloc> + node_allocator_traits; + + node_constructor<NodeAlloc> constructor; + + explicit move_nodes(NodeAlloc& a) : constructor(a) {} + + typename node_allocator_traits::pointer create( + typename node_allocator_traits::value_type::value_type& v) + { + constructor.construct_with_value2(boost::move(v)); + return constructor.release(); + } + }; + + template <typename Buckets> + struct assign_nodes + { + node_holder<typename Buckets::node_allocator> holder; + + explicit assign_nodes(Buckets& b) : holder(b) {} + + typename Buckets::node_pointer create( + typename Buckets::value_type const& v) + { + return holder.copy_of(v); + } + }; + + template <typename Buckets> + struct move_assign_nodes + { + node_holder<typename Buckets::node_allocator> holder; + + explicit move_assign_nodes(Buckets& b) : holder(b) {} + + typename Buckets::node_pointer create( + typename Buckets::value_type& v) + { + return holder.move_copy_of(v); + } + }; + template <typename Types> struct table : - boost::unordered::detail::buckets< - typename Types::allocator, - typename Types::bucket, - typename Types::node, - typename Types::policy>, boost::unordered::detail::functions< typename Types::hasher, typename Types::key_equal> @@ -69,6 +154,8 @@ namespace boost { namespace unordered { namespace detail { table(table const&); table& operator=(table const&); public: + typedef typename Types::node node; + typedef typename Types::bucket bucket; typedef typename Types::hasher hasher; typedef typename Types::key_equal key_equal; typedef typename Types::key_type key_type; @@ -81,24 +168,130 @@ namespace boost { namespace unordered { namespace detail { typedef boost::unordered::detail::functions< typename Types::hasher, typename Types::key_equal> functions; + typedef typename functions::set_hash_functions set_hash_functions; + + typedef typename Types::allocator allocator; + typedef typename boost::unordered::detail:: + rebind_wrap<allocator, node>::type node_allocator; + typedef typename boost::unordered::detail:: + rebind_wrap<allocator, bucket>::type bucket_allocator; + typedef boost::unordered::detail::allocator_traits<node_allocator> + node_allocator_traits; + typedef boost::unordered::detail::allocator_traits<bucket_allocator> + bucket_allocator_traits; + typedef typename node_allocator_traits::pointer + node_pointer; + typedef typename node_allocator_traits::const_pointer + const_node_pointer; + typedef typename bucket_allocator_traits::pointer + bucket_pointer; + typedef boost::unordered::detail::node_constructor<node_allocator> + node_constructor; + + typedef boost::unordered::iterator_detail:: + iterator<node> iterator; + typedef boost::unordered::iterator_detail:: + c_iterator<node, const_node_pointer> c_iterator; + typedef boost::unordered::iterator_detail:: + l_iterator<node, policy> l_iterator; + typedef boost::unordered::iterator_detail:: + cl_iterator<node, const_node_pointer, policy> cl_iterator; - typedef boost::unordered::detail::buckets< - typename Types::allocator, - typename Types::bucket, - typename Types::node, - typename Types::policy> buckets; + //////////////////////////////////////////////////////////////////////// + // Members - typedef typename buckets::node_allocator node_allocator; - typedef typename buckets::node_allocator_traits node_allocator_traits; - typedef typename buckets::node_pointer node_pointer; - typedef typename buckets::const_node_pointer const_node_pointer; + boost::unordered::detail::compressed<bucket_allocator, node_allocator> + allocators_; + std::size_t bucket_count_; + std::size_t size_; + float mlf_; + std::size_t max_load_; + bucket_pointer buckets_; - typedef typename table::iterator iterator; + //////////////////////////////////////////////////////////////////////// + // Data access - // Members + bucket_allocator const& bucket_alloc() const + { + return allocators_.first(); + } - float mlf_; - std::size_t max_load_; // Only use if this->buckets_. + node_allocator const& node_alloc() const + { + return allocators_.second(); + } + + bucket_allocator& bucket_alloc() + { + return allocators_.first(); + } + + node_allocator& node_alloc() + { + return allocators_.second(); + } + + std::size_t max_bucket_count() const + { + // -1 to account for the start bucket. + return policy::prev_bucket_count( + bucket_allocator_traits::max_size(bucket_alloc()) - 1); + } + + bucket_pointer get_bucket(std::size_t bucket_index) const + { + BOOST_ASSERT(buckets_); + return buckets_ + static_cast<std::ptrdiff_t>(bucket_index); + } + + link_pointer get_previous_start() const + { + return get_bucket(bucket_count_)->first_from_start(); + } + + link_pointer get_previous_start(std::size_t bucket_index) const + { + return get_bucket(bucket_index)->next_; + } + + iterator begin() const + { + return size_ ? iterator(get_previous_start()->next_) : iterator(); + } + + iterator begin(std::size_t bucket_index) const + { + if (!size_) return iterator(); + link_pointer prev = get_previous_start(bucket_index); + return prev ? iterator(prev->next_) : iterator(); + } + + std::size_t hash_to_bucket(std::size_t hash_value) const + { + return policy::to_bucket(bucket_count_, hash_value); + } + + float load_factor() const + { + BOOST_ASSERT(bucket_count_ != 0); + return static_cast<float>(size_) + / static_cast<float>(bucket_count_); + } + + std::size_t bucket_size(std::size_t index) const + { + iterator it = begin(index); + if (!it.node_) return 0; + + std::size_t count = 0; + while(it.node_ && hash_to_bucket(it.node_->hash_) == index) + { + ++count; + ++it; + } + + return count; + } //////////////////////////////////////////////////////////////////////// // Load methods @@ -109,34 +302,34 @@ namespace boost { namespace unordered { namespace detail { // size < mlf_ * count return boost::unordered::detail::double_to_size(ceil( - static_cast<double>(this->mlf_) * - static_cast<double>(this->max_bucket_count()) + static_cast<double>(mlf_) * + static_cast<double>(max_bucket_count()) )) - 1; } - std::size_t calculate_max_load() + void recalculate_max_load() { using namespace std; // From 6.3.1/13: // Only resize when size >= mlf_ * count - return boost::unordered::detail::double_to_size(ceil( - static_cast<double>(this->mlf_) * - static_cast<double>(this->bucket_count_) - )); + max_load_ = buckets_ ? boost::unordered::detail::double_to_size(ceil( + static_cast<double>(mlf_) * + static_cast<double>(bucket_count_) + )) : 0; } + void max_load_factor(float z) { BOOST_ASSERT(z > 0); mlf_ = (std::max)(z, minimum_max_load_factor); - if (this->buckets_) - this->max_load_ = this->calculate_max_load(); + recalculate_max_load(); } std::size_t min_buckets_for_size(std::size_t size) const { - BOOST_ASSERT(this->mlf_ >= minimum_max_load_factor); + BOOST_ASSERT(mlf_ >= minimum_max_load_factor); using namespace std; @@ -160,177 +353,407 @@ namespace boost { namespace unordered { namespace detail { hasher const& hf, key_equal const& eq, node_allocator const& a) : - buckets(a, policy::new_bucket_count(num_buckets)), functions(hf, eq), + allocators_(a,a), + bucket_count_(policy::new_bucket_count(num_buckets)), + size_(0), mlf_(1.0f), - max_load_(0) + max_load_(0), + buckets_() {} table(table const& x, node_allocator const& a) : - buckets(a, x.min_buckets_for_size(x.size_)), functions(x), + allocators_(a,a), + bucket_count_(x.min_buckets_for_size(x.size_)), + size_(0), mlf_(x.mlf_), - max_load_(0) - { - if(x.size_) { - table_impl::copy_buckets_to(x, *this); - this->max_load_ = calculate_max_load(); - } - } + max_load_(0), + buckets_() + {} - // TODO: Why calculate_max_load? table(table& x, boost::unordered::detail::move_tag m) : - buckets(x, m), - functions(x), + functions(x, m), + allocators_(x.allocators_, m), + bucket_count_(x.bucket_count_), + size_(x.size_), mlf_(x.mlf_), - max_load_(calculate_max_load()) - {} + max_load_(x.max_load_), + buckets_(x.buckets_) + { + x.buckets_ = bucket_pointer(); + x.size_ = 0; + x.max_load_ = 0; + } - // TODO: Why not calculate_max_load? - // TODO: Why do I use x's bucket count? table(table& x, node_allocator const& a, boost::unordered::detail::move_tag m) : - buckets(a, x.bucket_count_), - functions(x), + functions(x, m), + allocators_(a, a), + bucket_count_(x.bucket_count_), + size_(0), mlf_(x.mlf_), - max_load_(x.max_load_) + max_load_(x.max_load_), + buckets_() + {} + + //////////////////////////////////////////////////////////////////////// + // Initialisation. + + void init(table const& x) { - if(a == x.node_alloc()) { - this->buckets::swap(x, false_type()); + if (x.size_) { + create_buckets(bucket_count_); + copy_nodes<node_allocator> node_creator(node_alloc()); + table_impl::fill_buckets(x.begin(), *this, node_creator); + } + } + + void move_init(table& x) + { + if(node_alloc() == x.node_alloc()) { + move_buckets_from(x); } else if(x.size_) { - // Use a temporary table because move_buckets_to leaves the - // source container in a complete mess. + // TODO: Could pick new bucket size? + create_buckets(bucket_count_); - buckets tmp(x, m); - table_impl::move_buckets_to(tmp, *this); - this->max_load_ = calculate_max_load(); + move_nodes<node_allocator> node_creator(node_alloc()); + node_holder<node_allocator> nodes(x); + table_impl::fill_buckets(nodes.begin(), *this, node_creator); } } - // Iterators + //////////////////////////////////////////////////////////////////////// + // Create buckets + + void create_buckets(std::size_t new_count) + { + boost::unordered::detail::array_constructor<bucket_allocator> + constructor(bucket_alloc()); + + // Creates an extra bucket to act as the start node. + constructor.construct(bucket(), new_count + 1); + + if (buckets_) + { + // Copy the nodes to the new buckets, including the dummy + // node if there is one. + (constructor.get() + + static_cast<std::ptrdiff_t>(new_count))->next_ = + (buckets_ + static_cast<std::ptrdiff_t>( + bucket_count_))->next_; + destroy_buckets(); + } + else if (bucket::extra_node) + { + node_constructor a(node_alloc()); + a.construct(); + + (constructor.get() + + static_cast<std::ptrdiff_t>(new_count))->next_ = + a.release(); + } - iterator begin() const { - return !this->buckets_ ? - iterator() : this->get_start(); + bucket_count_ = new_count; + buckets_ = constructor.release(); + recalculate_max_load(); } - // Assignment + //////////////////////////////////////////////////////////////////////// + // Swap and Move - void assign(table const& x) + void swap_allocators(table& other, false_type) + { + boost::unordered::detail::func::ignore_unused_variable_warning(other); + + // According to 23.2.1.8, if propagate_on_container_swap is + // false the behaviour is undefined unless the allocators + // are equal. + BOOST_ASSERT(node_alloc() == other.node_alloc()); + } + + void swap_allocators(table& other, true_type) + { + allocators_.swap(other.allocators_); + } + + // Only swaps the allocators if propagate_on_container_swap + void swap(table& x) { - assign(x, + set_hash_functions op1(*this, x); + set_hash_functions op2(x, *this); + + // I think swap can throw if Propagate::value, + // since the allocators' swap can throw. Not sure though. + swap_allocators(x, boost::unordered::detail::integral_constant<bool, allocator_traits<node_allocator>:: - propagate_on_container_copy_assignment::value>()); + propagate_on_container_swap::value>()); + + boost::swap(buckets_, x.buckets_); + boost::swap(bucket_count_, x.bucket_count_); + boost::swap(size_, x.size_); + std::swap(mlf_, x.mlf_); + std::swap(max_load_, x.max_load_); + op1.commit(); + op2.commit(); + } + + void move_buckets_from(table& other) + { + BOOST_ASSERT(node_alloc() == other.node_alloc()); + BOOST_ASSERT(!buckets_); + buckets_ = other.buckets_; + bucket_count_ = other.bucket_count_; + size_ = other.size_; + other.buckets_ = bucket_pointer(); + other.size_ = 0; + other.max_load_ = 0; + } + + //////////////////////////////////////////////////////////////////////// + // Delete/destruct + + ~table() + { + delete_buckets(); + } + + void delete_node(link_pointer prev) + { + node_pointer n = static_cast<node_pointer>(prev->next_); + prev->next_ = n->next_; + + boost::unordered::detail::func::destroy_value_impl(node_alloc(), + n->value_ptr()); + boost::unordered::detail::func::destroy(boost::addressof(*n)); + node_allocator_traits::deallocate(node_alloc(), n, 1); + --size_; + } + + std::size_t delete_nodes(link_pointer prev, link_pointer end) + { + BOOST_ASSERT(prev->next_ != end); + + std::size_t count = 0; + + do { + delete_node(prev); + ++count; + } while (prev->next_ != end); + + return count; + } + + void delete_buckets() + { + if(buckets_) { + if (size_) delete_nodes(get_previous_start(), link_pointer()); + + if (bucket::extra_node) { + node_pointer n = static_cast<node_pointer>( + get_bucket(bucket_count_)->next_); + boost::unordered::detail::func::destroy( + boost::addressof(*n)); + node_allocator_traits::deallocate(node_alloc(), n, 1); + } + + destroy_buckets(); + buckets_ = bucket_pointer(); + max_load_ = 0; + } + + BOOST_ASSERT(!size_); + } + + void clear() + { + if (!size_) return; + + delete_nodes(get_previous_start(), link_pointer()); + clear_buckets(); + + BOOST_ASSERT(!size_); + } + + void clear_buckets() + { + bucket_pointer end = get_bucket(bucket_count_); + for(bucket_pointer it = buckets_; it != end; ++it) + { + it->next_ = node_pointer(); + } + } + + void destroy_buckets() + { + bucket_pointer end = get_bucket(bucket_count_ + 1); + for(bucket_pointer it = buckets_; it != end; ++it) + { + boost::unordered::detail::func::destroy( + boost::addressof(*it)); + } + + bucket_allocator_traits::deallocate(bucket_alloc(), + buckets_, bucket_count_ + 1); + } + + //////////////////////////////////////////////////////////////////////// + // Fix buckets after delete + // + + std::size_t fix_bucket(std::size_t bucket_index, link_pointer prev) + { + link_pointer end = prev->next_; + std::size_t bucket_index2 = bucket_index; + + if (end) + { + bucket_index2 = hash_to_bucket( + static_cast<node_pointer>(end)->hash_); + + // If begin and end are in the same bucket, then + // there's nothing to do. + if (bucket_index == bucket_index2) return bucket_index2; + + // Update the bucket containing end. + get_bucket(bucket_index2)->next_ = prev; + } + + // Check if this bucket is now empty. + bucket_pointer this_bucket = get_bucket(bucket_index); + if (this_bucket->next_ == prev) + this_bucket->next_ = link_pointer(); + + return bucket_index2; + } + + //////////////////////////////////////////////////////////////////////// + // Assignment + + void assign(table const& x) + { + if (this != boost::addressof(x)) + { + assign(x, + boost::unordered::detail::integral_constant<bool, + allocator_traits<node_allocator>:: + propagate_on_container_copy_assignment::value>()); + } } void assign(table const& x, false_type) { - table tmp(x, this->node_alloc()); - this->swap(tmp, false_type()); + // Strong exception safety. + set_hash_functions new_func_this(*this, x); + new_func_this.commit(); + mlf_ = x.mlf_; + recalculate_max_load(); + + if (!size_ && !x.size_) return; + + if (x.size_ >= max_load_) { + create_buckets(min_buckets_for_size(x.size_)); + } + else { + clear_buckets(); + } + + // assign_nodes takes ownership of the container's elements, + // assigning to them if possible, and deleting any that are + // left over. + assign_nodes<table> node_creator(*this); + table_impl::fill_buckets(x.begin(), *this, node_creator); } void assign(table const& x, true_type) { - table tmp(x, x.node_alloc()); - // Need to delete before setting the allocator so that buckets - // aren't deleted with the wrong allocator. - if(this->buckets_) this->delete_buckets(); - // TODO: Can allocator assignment throw? - this->allocators_.assign(x.allocators_); - this->swap(tmp, false_type()); + if (node_alloc() == x.node_alloc()) { + allocators_.assign(x.allocators_); + assign(x, false_type()); + } + else { + set_hash_functions new_func_this(*this, x); + + // Delete everything with current allocators before assigning + // the new ones. + delete_buckets(); + allocators_.assign(x.allocators_); + + // Copy over other data, all no throw. + new_func_this.commit(); + mlf_ = x.mlf_; + bucket_count_ = min_buckets_for_size(x.size_); + max_load_ = 0; + + // Finally copy the elements. + if (x.size_) { + create_buckets(bucket_count_); + copy_nodes<node_allocator> node_creator(node_alloc()); + table_impl::fill_buckets(x.begin(), *this, node_creator); + } + } } void move_assign(table& x) { - move_assign(x, - boost::unordered::detail::integral_constant<bool, - allocator_traits<node_allocator>:: - propagate_on_container_move_assignment::value>()); + if (this != boost::addressof(x)) + { + move_assign(x, + boost::unordered::detail::integral_constant<bool, + allocator_traits<node_allocator>:: + propagate_on_container_move_assignment::value>()); + } } void move_assign(table& x, true_type) { - if(this->buckets_) this->delete_buckets(); - this->allocators_.move_assign(x.allocators_); + delete_buckets(); + allocators_.move_assign(x.allocators_); move_assign_no_alloc(x); } void move_assign(table& x, false_type) { - if(this->node_alloc() == x.node_alloc()) { - if(this->buckets_) this->delete_buckets(); + if (node_alloc() == x.node_alloc()) { + delete_buckets(); move_assign_no_alloc(x); } else { - boost::unordered::detail::set_hash_functions<hasher, key_equal> - new_func_this(*this, x); + set_hash_functions new_func_this(*this, x); + new_func_this.commit(); + mlf_ = x.mlf_; + recalculate_max_load(); - if (x.size_) { - buckets b(this->node_alloc(), - x.min_buckets_for_size(x.size_)); - buckets tmp(x, move_tag()); - table_impl::move_buckets_to(tmp, b); - b.swap(*this); + if (!size_ && !x.size_) return; + + if (x.size_ >= max_load_) { + create_buckets(min_buckets_for_size(x.size_)); } else { - this->clear(); + clear_buckets(); } - - this->mlf_ = x.mlf_; - if (this->buckets_) this->max_load_ = calculate_max_load(); - new_func_this.commit(); + + // 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> node_creator(*this); + node_holder<node_allocator> nodes(x); + table_impl::fill_buckets(nodes.begin(), *this, node_creator); } } void move_assign_no_alloc(table& x) { - boost::unordered::detail::set_hash_functions<hasher, key_equal> - new_func_this(*this, x); + set_hash_functions new_func_this(*this, x); // No throw from here. - this->move_buckets_from(x); - this->mlf_ = x.mlf_; - this->max_load_ = x.max_load_; + mlf_ = x.mlf_; + max_load_ = x.max_load_; + move_buckets_from(x); new_func_this.commit(); } - //////////////////////////////////////////////////////////////////////// - // Swap & Move - - void swap(table& x) - { - swap(x, - boost::unordered::detail::integral_constant<bool, - allocator_traits<node_allocator>:: - propagate_on_container_swap::value>()); - } - - // Only swaps the allocators if Propagate::value - template <typename Propagate> - void swap(table& x, Propagate p) - { - boost::unordered::detail::set_hash_functions<hasher, key_equal> - op1(*this, x); - boost::unordered::detail::set_hash_functions<hasher, key_equal> - op2(x, *this); - // I think swap can throw if Propagate::value, - // since the allocators' swap can throw. Not sure though. - this->buckets::swap(x, p); - std::swap(this->mlf_, x.mlf_); - std::swap(this->max_load_, x.max_load_); - op1.commit(); - op2.commit(); - } - - // Swap everything but the allocators, and the functions objects. - void swap_contents(table& x) - { - this->buckets::swap(x, false_type()); - std::swap(this->mlf_, x.mlf_); - std::swap(this->max_load_, x.max_load_); - } - // Accessors key_type const& get_key(value_type const& x) const @@ -351,7 +774,6 @@ namespace boost { namespace unordered { namespace detail { Hash const& hf, Pred const& eq) const { - if (!this->size_) return iterator(); return static_cast<table_impl const*>(this)-> find_node_impl(policy::apply_hash(hf, k), k, eq); } @@ -360,16 +782,14 @@ namespace boost { namespace unordered { namespace detail { std::size_t key_hash, key_type const& k) const { - if (!this->size_) return iterator(); return static_cast<table_impl const*>(this)-> find_node_impl(key_hash, k, this->key_eq()); } iterator find_node(key_type const& k) const { - if (!this->size_) return iterator(); return static_cast<table_impl const*>(this)-> - find_node_impl(this->hash(k), k, this->key_eq()); + find_node_impl(hash(k), k, this->key_eq()); } iterator find_matching_node(iterator n) const @@ -397,22 +817,19 @@ namespace boost { namespace unordered { namespace detail { template <typename Types> inline void table<Types>::reserve_for_insert(std::size_t size) { - if (!this->buckets_) { - this->bucket_count_ = (std::max)(this->bucket_count_, - this->min_buckets_for_size(size)); - this->create_buckets(); - this->max_load_ = this->calculate_max_load(); + if (!buckets_) { + create_buckets((std::max)(bucket_count_, + min_buckets_for_size(size))); } // According to the standard this should be 'size >= max_load_', // but I think this is better, defect report filed. else if(size > max_load_) { std::size_t num_buckets - = this->min_buckets_for_size((std::max)(size, - this->size_ + (this->size_ >> 1))); - if (num_buckets != this->bucket_count_) { + = min_buckets_for_size((std::max)(size, + size_ + (size_ >> 1))); + + if (num_buckets != bucket_count_) static_cast<table_impl*>(this)->rehash_impl(num_buckets); - this->max_load_ = this->calculate_max_load(); - } } } @@ -424,20 +841,18 @@ namespace boost { namespace unordered { namespace detail { { using namespace std; - if(!this->size_) { - if(this->buckets_) this->delete_buckets(); - this->bucket_count_ = policy::new_bucket_count(min_buckets); + if(!size_) { + delete_buckets(); + bucket_count_ = policy::new_bucket_count(min_buckets); } else { min_buckets = policy::new_bucket_count((std::max)(min_buckets, boost::unordered::detail::double_to_size(floor( - static_cast<double>(this->size_) / + static_cast<double>(size_) / static_cast<double>(mlf_))) + 1)); - if(min_buckets != this->bucket_count_) { + if(min_buckets != bucket_count_) static_cast<table_impl*>(this)->rehash_impl(min_buckets); - this->max_load_ = this->calculate_max_load(); - } } } @@ -445,8 +860,12 @@ namespace boost { namespace unordered { namespace detail { inline void table<Types>::reserve(std::size_t num_elements) { rehash(static_cast<std::size_t>( - std::ceil(static_cast<double>(num_elements) / this->mlf_))); + std::ceil(static_cast<double>(num_elements) / mlf_))); } }}} +#if defined(BOOST_MSVC) +#pragma warning(pop) +#endif + #endif |