comparison DEPENDENCIES/generic/include/boost/unordered/detail/table.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #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>

         typedef ValueType value_type;
 
         typename boost::aligned_storage<
             sizeof(value_type),
             boost::alignment_of<value_type>::value>::type data_;
+
+        value_base() :
+            data_()
+        {}
 
         void* address() {
             return this;
         }
 

             node_constructor;
 
         typedef boost::unordered::iterator_detail::
             iterator<node> iterator;
         typedef boost::unordered::iterator_detail::
-            c_iterator<node, const_node_pointer> c_iterator;
+            c_iterator<node> 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;
+            cl_iterator<node, policy> cl_iterator;
 
         ////////////////////////////////////////////////////////////////////////
         // Members
 
         boost::unordered::detail::compressed<bucket_allocator, node_allocator>

             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) const
-        {
-            return policy::to_bucket(bucket_count_, hash);
+        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);

             // count > size / mlf_
 
             return policy::new_bucket_count(
                 boost::unordered::detail::double_to_size(floor(
                     static_cast<double>(size) /
-                    static_cast<double>(mlf_))) + 1);
+                    static_cast<double>(mlf_)) + 1));
         }
 
         ////////////////////////////////////////////////////////////////////////
         // Constructors
 

 
         void init(table const& x)
         {
             if (x.size_) {
                 create_buckets(bucket_count_);
-                copy_nodes<node_allocator> copy(node_alloc());
-                table_impl::fill_buckets(x.begin(), *this, copy);
+                copy_nodes<node_allocator> node_creator(node_alloc());
+                table_impl::fill_buckets(x.begin(), *this, node_creator);
             }
         }
 
         void move_init(table& x)
         {

             }
             else if(x.size_) {
                 // TODO: Could pick new bucket size?
                 create_buckets(bucket_count_);
 
-                move_nodes<node_allocator> move(node_alloc());
+                move_nodes<node_allocator> node_creator(node_alloc());
                 node_holder<node_allocator> nodes(x);
-                table_impl::fill_buckets(nodes.begin(), *this, move);
+                table_impl::fill_buckets(nodes.begin(), *this, node_creator);
             }
         }
 
         ////////////////////////////////////////////////////////////////////////
         // Create buckets

             std::swap(max_load_, x.max_load_);
             op1.commit();
             op2.commit();
         }
 
+        // Only call with nodes allocated with the currect allocator, or
+        // one that is equal to it. (Can't assert because other's
+        // allocators might have already been moved).
         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();

             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());
-            node_allocator_traits::destroy(node_alloc(),
-                    boost::addressof(*n));
+            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)

                 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_);
-                    node_allocator_traits::destroy(node_alloc(),
+                    boost::unordered::detail::func::destroy(
                             boost::addressof(*n));
                     node_allocator_traits::deallocate(node_alloc(), n, 1);
                 }
 
                 destroy_buckets();

         void destroy_buckets()
         {
             bucket_pointer end = get_bucket(bucket_count_ + 1);
             for(bucket_pointer it = buckets_; it != end; ++it)
             {
-                bucket_allocator_traits::destroy(bucket_alloc(),
+                boost::unordered::detail::func::destroy(
                     boost::addressof(*it));
             }
 
             bucket_allocator_traits::deallocate(bucket_alloc(),
                 buckets_, bucket_count_ + 1);

             }
 
             // 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> node_creator(*this);
+            table_impl::fill_buckets(x.begin(), *this, node_creator);
         }
 
         void assign(table const& x, true_type)
         {
             if (node_alloc() == x.node_alloc()) {

                 max_load_ = 0;
 
                 // Finally copy the elements.
                 if (x.size_) {
                     create_buckets(bucket_count_);
-                    copy_nodes<node_allocator> copy(node_alloc());
-                    table_impl::fill_buckets(x.begin(), *this, copy);
+                    copy_nodes<node_allocator> node_creator(node_alloc());
+                    table_impl::fill_buckets(x.begin(), *this, node_creator);
                 }
             }
         }
 
         void move_assign(table& x)

         }
 
         void move_assign(table& x, true_type)
         {
             delete_buckets();
+            set_hash_functions new_func_this(*this, x);
             allocators_.move_assign(x.allocators_);
-            move_assign_no_alloc(x);
+            // No throw from here.
+            mlf_ = x.mlf_;
+            max_load_ = x.max_load_;
+            move_buckets_from(x);
+            new_func_this.commit();
         }
 
         void move_assign(table& x, false_type)
         {
             if (node_alloc() == x.node_alloc()) {
                 delete_buckets();
-                move_assign_no_alloc(x);
+                set_hash_functions new_func_this(*this, x);
+                // No throw from here.
+                mlf_ = x.mlf_;
+                max_load_ = x.max_load_;
+                move_buckets_from(x);
+                new_func_this.commit();
             }
             else {
                 set_hash_functions new_func_this(*this, x);
                 new_func_this.commit();
                 mlf_ = x.mlf_;

                 }
 
                 // 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> node_creator(*this);
                 node_holder<node_allocator> nodes(x);
-                table_impl::fill_buckets(nodes.begin(), *this, assign);
-            }
-        }
-        
-        void move_assign_no_alloc(table& x)
-        {
-            set_hash_functions new_func_this(*this, x);
-            // No throw from here.
-            mlf_ = x.mlf_;
-            max_load_ = x.max_load_;
-            move_buckets_from(x);
-            new_func_this.commit();
+                table_impl::fill_buckets(nodes.begin(), *this, node_creator);
+            }
         }
 
         // Accessors
 
         key_type const& get_key(value_type const& x) const