comparison DEPENDENCIES/generic/include/boost/intrusive/unordered_set.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 /////////////////////////////////////////////////////////////////////////////
 //
 // (C) Copyright Olaf Krzikalla 2004-2006.
-// (C) Copyright Ion Gaztanaga  2006-2013
+// (C) Copyright Ion Gaztanaga  2006-2014
 //
 // 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)
 //

 #define BOOST_INTRUSIVE_UNORDERED_SET_HPP
 
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
 #include <boost/intrusive/hashtable.hpp>
-#include <boost/move/move.hpp>
-#include <iterator>
-
+#include <boost/move/utility_core.hpp>
+#include <boost/static_assert.hpp>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
 
 namespace boost {
 namespace intrusive {
 
 //! The class template unordered_set is an intrusive container, that mimics most of

    //!   and Dereferencing iterator must yield an lvalue of type value_type.
    //!
    //! <b>Effects</b>: Constructs an empty unordered_set and inserts elements from
    //!   [b, e).
    //!
-   //! <b>Complexity</b>: If N is std::distance(b, e): Average case is O(N)
+   //! <b>Complexity</b>: If N is distance(b, e): Average case is O(N)
    //!   (with a good hash function and with buckets_len >= N),worst case O(N2).
    //!
    //! <b>Throws</b>: If value_traits::node_traits::node
    //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
    //!   or the copy constructor or invocation of hasher or key_equal throws.

    {  table_type::insert_unique(b, e);  }
 
    //! <b>Effects</b>: to-do
    //!
    unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
-      :  table_type(::boost::move(static_cast<table_type&>(x)))
+      :  table_type(BOOST_MOVE_BASE(table_type, x))
    {}
 
    //! <b>Effects</b>: to-do
    //!
    unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x)
-   {  return static_cast<unordered_set_impl&>(table_type::operator=(::boost::move(static_cast<table_type&>(x)))); }
+   {  return static_cast<unordered_set_impl&>(table_type::operator=(BOOST_MOVE_BASE(table_type, x))); }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
    //! <b>Effects</b>: Detaches all elements from this. The objects in the unordered_set
    //!   are not deleted (i.e. no destructors are called).
    //!

    //! <b>Requires</b>: Dereferencing iterator must yield an lvalue
    //!   of type value_type.
    //!
    //! <b>Effects</b>: Equivalent to this->insert(t) for each element in [b, e).
    //!
-   //! <b>Complexity</b>: Average case O(N), where N is std::distance(b, e).
+   //! <b>Complexity</b>: Average case O(N), where N is distance(b, e).
    //!   Worst case O(N*this->size()).
    //!
    //! <b>Throws</b>: If the internal hasher or the equality functor throws. Basic guarantee.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.

    void erase(const_iterator i)
    {  table_type::erase(i);  }
 
    //! <b>Effects</b>: Erases the range pointed to by b end e.
    //!
-   //! <b>Complexity</b>: Average case O(std::distance(b, e)),
+   //! <b>Complexity</b>: Average case O(distance(b, e)),
    //!   worst case O(this->size()).
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references)

    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
    //! <b>Effects</b>: Erases the range pointed to by b end e.
    //!   Disposer::operator()(pointer) is called for the removed elements.
    //!
-   //! <b>Complexity</b>: Average case O(std::distance(b, e)),
+   //! <b>Complexity</b>: Average case O(distance(b, e)),
    //!   worst case O(this->size()).
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Note</b>: Invalidates the iterators

       >::type packed_options;
 
    typedef typename detail::get_value_traits
       <T, typename packed_options::proto_value_traits>::type value_traits;
 
-   typedef typename make_real_bucket_traits
-            <T, true, packed_options>::type real_bucket_traits;
+   typedef typename make_bucket_traits
+            <T, true, packed_options>::type bucket_traits;
 
    typedef unordered_set_impl
       < value_traits
       , typename packed_options::hash
       , typename packed_options::equal
       , typename packed_options::size_type
-      , real_bucket_traits
+      , bucket_traits
       ,  (std::size_t(true)*hash_bool_flags::unique_keys_pos)
       |  (std::size_t(packed_options::constant_time_size)*hash_bool_flags::constant_time_size_pos)
       |  (std::size_t(packed_options::power_2_buckets)*hash_bool_flags::power_2_buckets_pos)
       |  (std::size_t(packed_options::cache_begin)*hash_bool_flags::cache_begin_pos)
       |  (std::size_t(packed_options::compare_hash)*hash_bool_flags::compare_hash_pos)

                   , const value_traits &v_traits = value_traits())
       :  Base(b, e, b_traits, hash_func, equal_func, v_traits)
    {}
 
    unordered_set(BOOST_RV_REF(unordered_set) x)
-      :  Base(::boost::move(static_cast<Base&>(x)))
+      :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
    unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
-   {  return static_cast<unordered_set&>(this->Base::operator=(::boost::move(static_cast<Base&>(x))));  }
+   {  return static_cast<unordered_set&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 };
 
 #endif
 
 

    //!   and Dereferencing iterator must yield an lvalue of type value_type.
    //!
    //! <b>Effects</b>: Constructs an empty unordered_multiset and inserts elements from
    //!   [b, e).
    //!
-   //! <b>Complexity</b>: If N is std::distance(b, e): Average case is O(N)
+   //! <b>Complexity</b>: If N is distance(b, e): Average case is O(N)
    //!   (with a good hash function and with buckets_len >= N),worst case O(N2).
    //!
    //! <b>Throws</b>: If value_traits::node_traits::node
    //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
    //!   or the copy constructor or invocation of hasher or key_equal throws.

    {  table_type::insert_equal(b, e);  }
 
    //! <b>Effects</b>: to-do
    //!
    unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
-      :  table_type(::boost::move(static_cast<table_type&>(x)))
+      :  table_type(BOOST_MOVE_BASE(table_type, x))
    {}
 
    //! <b>Effects</b>: to-do
    //!
    unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x)
-   {  return static_cast<unordered_multiset_impl&>(table_type::operator=(::boost::move(static_cast<table_type&>(x))));  }
+   {  return static_cast<unordered_multiset_impl&>(table_type::operator=(BOOST_MOVE_BASE(table_type, x)));  }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
    //! <b>Effects</b>: Detaches all elements from this. The objects in the unordered_multiset
    //!   are not deleted (i.e. no destructors are called).

    void erase(const_iterator i)
    {  table_type::erase(i);  }
 
    //! <b>Effects</b>: Erases the range pointed to by b end e.
    //!
-   //! <b>Complexity</b>: Average case O(std::distance(b, e)),
+   //! <b>Complexity</b>: Average case O(distance(b, e)),
    //!   worst case O(this->size()).
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references)

    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
    //! <b>Effects</b>: Erases the range pointed to by b end e.
    //!   Disposer::operator()(pointer) is called for the removed elements.
    //!
-   //! <b>Complexity</b>: Average case O(std::distance(b, e)),
+   //! <b>Complexity</b>: Average case O(distance(b, e)),
    //!   worst case O(this->size()).
    //!
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Note</b>: Invalidates the iterators

       >::type packed_options;
 
    typedef typename detail::get_value_traits
       <T, typename packed_options::proto_value_traits>::type value_traits;
 
-   typedef typename make_real_bucket_traits
-            <T, true, packed_options>::type real_bucket_traits;
+   typedef typename make_bucket_traits
+            <T, true, packed_options>::type bucket_traits;
 
    typedef unordered_multiset_impl
       < value_traits
       , typename packed_options::hash
       , typename packed_options::equal
       , typename packed_options::size_type
-      , real_bucket_traits
+      , bucket_traits
       ,  (std::size_t(false)*hash_bool_flags::unique_keys_pos)
       |  (std::size_t(packed_options::constant_time_size)*hash_bool_flags::constant_time_size_pos)
       |  (std::size_t(packed_options::power_2_buckets)*hash_bool_flags::power_2_buckets_pos)
       |  (std::size_t(packed_options::cache_begin)*hash_bool_flags::cache_begin_pos)
       |  (std::size_t(packed_options::compare_hash)*hash_bool_flags::compare_hash_pos)

                      , const value_traits &v_traits = value_traits())
       :  Base(b, e, b_traits, hash_func, equal_func, v_traits)
    {}
 
    unordered_multiset(BOOST_RV_REF(unordered_multiset) x)
-      :  Base(::boost::move(static_cast<Base&>(x)))
+      :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
    unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
-   {  return static_cast<unordered_multiset&>(this->Base::operator=(::boost::move(static_cast<Base&>(x))));  }
+   {  return static_cast<unordered_multiset&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 };
 
 #endif
 
 } //namespace intrusive