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

Update Boost headers (1.58.0)

 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #ifndef BOOST_UNORDERED_DETAIL_UNIQUE_HPP_INCLUDED
 #define BOOST_UNORDERED_DETAIL_UNIQUE_HPP_INCLUDED
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
 #endif
 
 #include <boost/unordered/detail/table.hpp>
 #include <boost/unordered/detail/extract_key.hpp>
 #include <boost/throw_exception.hpp>

     template <typename A, typename T>
     struct unique_node :
         boost::unordered::detail::value_base<T>
     {
         typedef typename ::boost::unordered::detail::rebind_wrap<
-            A, unique_node<A, T> >::type::pointer node_pointer;
+            A, unique_node<A, T> >::type allocator;
+        typedef typename ::boost::unordered::detail::
+            allocator_traits<allocator>::pointer node_pointer;
         typedef node_pointer link_pointer;
 
         link_pointer next_;
         std::size_t hash_;
 

         unique_node& operator=(unique_node const&);
     };
 
     template <typename T>
     struct ptr_node :
-        boost::unordered::detail::value_base<T>,
         boost::unordered::detail::ptr_bucket
     {
+        typedef T value_type;
         typedef boost::unordered::detail::ptr_bucket bucket_base;
         typedef ptr_node<T>* node_pointer;
         typedef ptr_bucket* link_pointer;
 
         std::size_t hash_;
+        boost::unordered::detail::value_base<T> value_base_;
 
         ptr_node() :
             bucket_base(),
             hash_(0)
         {}
 
         void init(node_pointer)
         {
         }
+
+        void* address() { return value_base_.address(); }
+        value_type& value() { return value_base_.value(); }
+        value_type* value_ptr() { return value_base_.value_ptr(); }
 
     private:
         ptr_node& operator=(ptr_node const&);
     };
 

         typedef typename pick::link_pointer link_pointer;
 
         typedef boost::unordered::detail::table_impl<types> table;
         typedef boost::unordered::detail::set_extractor<value_type> extractor;
 
-        typedef boost::unordered::detail::pick_policy::type policy;
+        typedef typename boost::unordered::detail::pick_policy<T>::type policy;
     };
 
     template <typename A, typename K, typename M, typename H, typename P>
     struct map
     {

 
         typedef boost::unordered::detail::table_impl<types> table;
         typedef boost::unordered::detail::map_extractor<key_type, value_type>
             extractor;
 
-        typedef boost::unordered::detail::pick_policy::type policy;
+        typedef typename boost::unordered::detail::pick_policy<K>::type policy;
     };
 
     template <typename Types>
     struct table_impl : boost::unordered::detail::table<Types>
     {

                 prev = prev->next_;
             }
 
             link_pointer end = static_cast<node_pointer>(prev->next_)->next_;
 
-            std::size_t count = this->delete_nodes(prev, end);
+            std::size_t deleted_count = this->delete_nodes(prev, end);
             this->fix_bucket(bucket_index, prev);
-            return count;
+            return deleted_count;
         }
 
         iterator erase(c_iterator r)
         {
             BOOST_ASSERT(r.node_);

             if (r1 == r2) return iterator(r2.node_);
             erase_nodes(r1.node_, r2.node_);
             return iterator(r2.node_);
         }
 
-        void erase_nodes(node_pointer begin, node_pointer end)
-        {
-            std::size_t bucket_index = this->hash_to_bucket(begin->hash_);
-
-            // Find the node before begin.
+        void erase_nodes(node_pointer i, node_pointer j)
+        {
+            std::size_t bucket_index = this->hash_to_bucket(i->hash_);
+
+            // Find the node before i.
             link_pointer prev = this->get_previous_start(bucket_index);
-            while(prev->next_ != begin) prev = prev->next_;
+            while(prev->next_ != i) prev = prev->next_;
 
             // Delete the nodes.
             do {
                 this->delete_node(prev);
                 bucket_index = this->fix_bucket(bucket_index, prev);
-            } while (prev->next_ != end);
+            } while (prev->next_ != j);
         }
 
         ////////////////////////////////////////////////////////////////////////
         // fill_buckets