Boost 1.42.0

[SVN r59432]

doc/Jamfile.v2

@@ -8,6 +8,11 @@ path-constant admonishment_location : ../../../../doc/src/images ;
 
 xml unordered : unordered.qbk ;
 boostbook standalone : unordered :
+    <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
+    <xsl:param>boost.root=../../../..
+    <xsl:param>boost.libraries=../../../libraries.htm
+    <xsl:param>navig.graphics=1
+
     <xsl:param>chunk.first.sections=1
     <xsl:param>chunk.section.depth=2
     <xsl:param>generate.section.toc.level=2
@@ -18,15 +23,7 @@ boostbook standalone : unordered :
     <xsl:param>boost.compact.function=0
     <xsl:param>boost.compact.enum=0
 
-    # HTML Options:
-
-    <format>html:<xsl:param>boost.root=../../../..
-    <format>html:<xsl:param>img.src.path=../../../../doc/html/
-    <format>xhtml:<xsl:param>boost.root=../../../..
-    <format>xhtml:<xsl:param>img.src.path=../../../../doc/html/
-
     # PDF Options:
-
     # TOC Generation: this is needed for FOP-0.9 and later:
     <xsl:param>fop1.extensions=0
     <format>pdf:<xsl:param>xep.extensions=1

doc/changes.qbk

@@ -117,16 +117,4 @@ First official release.
   Add missing `std` qualifier to `ptrdiff_t`.
 * Some code formatting changes to fit almost all lines into 80 characters.
 
-[h2 Boost 1.43.0]
-
-* [@http://svn.boost.org/trac/boost/ticket/3966 Ticket 3966]:
-  `erase_return_void` is now `quick_erase`, which is the
-  [@http://home.roadrunner.com/~hinnant/issue_review/lwg-active.html#579
-  current forerunner for resolving the slow erase by iterator], although
-  there's a strong possibility that this may change in the future. The old
-  method name remains for backwards compatibility but is considered deprecated
-  and will be removed in a future release.
-* Use Boost.Exception.
-* Stop using deprecated `BOOST_HAS_*` macros.
-
 [endsect]

doc/ref.xml

@@ -464,8 +464,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                   When the number of elements is a lot smaller than the number of buckets
                   this function can be very inefficient as it has to search through empty
                   buckets for the next element, in order to return the iterator.
-                  The method <methodname>quick_erase</methodname> is faster, but has yet
-                  to be standardized.
+                  As a temporary workaround, the container has the method
+                  <methodname>erase_return_void</methodname> which will be faster.
                 </para>
               </notes>
             </method>
@@ -503,30 +503,6 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                 <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
               </throws>
             </method>
-            <method name="quick_erase">
-              <parameter name="position">
-                <paramtype>const_iterator</paramtype>
-              </parameter>
-              <type>void</type>
-              <description>
-                <para>Erase the element pointed to by <code>position</code>.</para>
-              </description>
-              <throws>
-                <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
-                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
-              </throws>
-              <notes>
-                <para>
-                  This method is faster than <methodname>erase</methodname> as
-                  it doesn't have to find the next element in the container -
-                  a potentially costly operation.
-                </para>
-                <para>
-                  As it hasn't been standardized, it's likely that this may
-                  change in the future.
-                </para>
-              </notes>
-            </method>
             <method name="erase_return_void">
               <parameter name="position">
                 <paramtype>const_iterator</paramtype>
@@ -541,10 +517,10 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               </throws>
               <notes>
                 <para>
-                  This method is now deprecated, use
-                  <methodname>quick_return</methodname> instead. Although be
-                  warned that as that isn't standardized yet, it could also
-                  change.
+                  This is a temporary workaround for the inefficient
+                  <methodname>erase</methodname> method. Hopefully, in a future
+                  version the signature of <methodname>erase</methodname> will
+                  be changed and this will be deprecated.
                 </para>
               </notes>
             </method>
@@ -1351,8 +1327,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                   When the number of elements is a lot smaller than the number of buckets
                   this function can be very inefficient as it has to search through empty
                   buckets for the next element, in order to return the iterator.
-                  The method <methodname>quick_erase</methodname> is faster, but has yet
-                  to be standardized.
+                  As a temporary workaround, the container has the method
+                  <methodname>erase_return_void</methodname> which will be faster.
                 </para>
               </notes>
             </method>
@@ -1390,30 +1366,6 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                 <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
               </throws>
             </method>
-            <method name="quick_erase">
-              <parameter name="position">
-                <paramtype>const_iterator</paramtype>
-              </parameter>
-              <type>void</type>
-              <description>
-                <para>Erase the element pointed to by <code>position</code>.</para>
-              </description>
-              <throws>
-                <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
-                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
-              </throws>
-              <notes>
-                <para>
-                  This method is faster than <methodname>erase</methodname> as
-                  it doesn't have to find the next element in the container -
-                  a potentially costly operation.
-                </para>
-                <para>
-                  As it hasn't been standardized, it's likely that this may
-                  change in the future.
-                </para>
-              </notes>
-            </method>
             <method name="erase_return_void">
               <parameter name="position">
                 <paramtype>const_iterator</paramtype>
@@ -1428,10 +1380,10 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               </throws>
               <notes>
                 <para>
-                  This method is now deprecated, use
-                  <methodname>quick_return</methodname> instead. Although be
-                  warned that as that isn't standardized yet, it could also
-                  change.
+                  This is a temporary workaround for the inefficient
+                  <methodname>erase</methodname> method. Hopefully, in a future
+                  version the signature of <methodname>erase</methodname> will
+                  be changed and this will be deprecated.
                 </para>
               </notes>
             </method>
@@ -2252,8 +2204,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                   When the number of elements is a lot smaller than the number of buckets
                   this function can be very inefficient as it has to search through empty
                   buckets for the next element, in order to return the iterator.
-                  The method <methodname>quick_erase</methodname> is faster, but has yet
-                  to be standardized.
+                  As a temporary workaround, the container has the method
+                  <methodname>erase_return_void</methodname> which will be faster.
                 </para>
               </notes>
             </method>
@@ -2291,30 +2243,6 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                 <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
               </throws>
             </method>
-            <method name="quick_erase">
-              <parameter name="position">
-                <paramtype>const_iterator</paramtype>
-              </parameter>
-              <type>void</type>
-              <description>
-                <para>Erase the element pointed to by <code>position</code>.</para>
-              </description>
-              <throws>
-                <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
-                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
-              </throws>
-              <notes>
-                <para>
-                  This method is faster than <methodname>erase</methodname> as
-                  it doesn't have to find the next element in the container -
-                  a potentially costly operation.
-                </para>
-                <para>
-                  As it hasn't been standardized, it's likely that this may
-                  change in the future.
-                </para>
-              </notes>
-            </method>
             <method name="erase_return_void">
               <parameter name="position">
                 <paramtype>const_iterator</paramtype>
@@ -2329,10 +2257,10 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               </throws>
               <notes>
                 <para>
-                  This method is now deprecated, use
-                  <methodname>quick_return</methodname> instead. Although be
-                  warned that as that isn't standardized yet, it could also
-                  change.
+                  This is a temporary workaround for the inefficient
+                  <methodname>erase</methodname> method. Hopefully, in a future
+                  version the signature of <methodname>erase</methodname> will
+                  be changed and this will be deprecated.
                 </para>
               </notes>
             </method>
@@ -3188,8 +3116,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                   When the number of elements is a lot smaller than the number of buckets
                   this function can be very inefficient as it has to search through empty
                   buckets for the next element, in order to return the iterator.
-                  The method <methodname>quick_erase</methodname> is faster, but has yet
-                  to be standardized.
+                  As a temporary workaround, the container has the method
+                  <methodname>erase_return_void</methodname> which will be faster.
                 </para>
               </notes>
             </method>
@@ -3227,30 +3155,6 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                 <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
               </throws>
             </method>
-            <method name="quick_erase">
-              <parameter name="position">
-                <paramtype>const_iterator</paramtype>
-              </parameter>
-              <type>void</type>
-              <description>
-                <para>Erase the element pointed to by <code>position</code>.</para>
-              </description>
-              <throws>
-                <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
-                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
-              </throws>
-              <notes>
-                <para>
-                  This method is faster than <methodname>erase</methodname> as
-                  it doesn't have to find the next element in the container -
-                  a potentially costly operation.
-                </para>
-                <para>
-                  As it hasn't been standardized, it's likely that this may
-                  change in the future.
-                </para>
-              </notes>
-            </method>
             <method name="erase_return_void">
               <parameter name="position">
                 <paramtype>const_iterator</paramtype>
@@ -3265,10 +3169,10 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               </throws>
               <notes>
                 <para>
-                  This method is now deprecated, use
-                  <methodname>quick_return</methodname> instead. Although be
-                  warned that as that isn't standardized yet, it could also
-                  change.
+                  This is a temporary workaround for the inefficient
+                  <methodname>erase</methodname> method. Hopefully, in a future
+                  version the signature of <methodname>erase</methodname> will
+                  be changed and this will be deprecated.
                 </para>
               </notes>
             </method>

doc/unordered.qbk

@@ -13,7 +13,7 @@
     [license
         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])
+        [@http://www.boost.org/LICENSE_1_0.txt]
     ]
 ]
 

include/boost/unordered/detail/equivalent.hpp

@@ -12,101 +12,6 @@
 
 namespace boost { namespace unordered_detail {
 
-    template <class T>
-    class hash_equivalent_table : public T::table
-    {
-    public:
-        typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
-        typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
-        typedef BOOST_DEDUCED_TYPENAME T::value_allocator value_allocator;
-        typedef BOOST_DEDUCED_TYPENAME T::key_type key_type;
-        typedef BOOST_DEDUCED_TYPENAME T::value_type value_type;
-        typedef BOOST_DEDUCED_TYPENAME T::table table;
-        typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor;
-
-        typedef BOOST_DEDUCED_TYPENAME T::node node;
-        typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr;
-        typedef BOOST_DEDUCED_TYPENAME T::bucket_ptr bucket_ptr;
-        typedef BOOST_DEDUCED_TYPENAME T::iterator_base iterator_base;
-        typedef BOOST_DEDUCED_TYPENAME T::extractor extractor;
-
-        // Constructors
-
-        hash_equivalent_table(std::size_t n,
-            hasher const& hf, key_equal const& eq, value_allocator const& a)
-          : table(n, hf, eq, a) {}
-        hash_equivalent_table(hash_equivalent_table const& x)
-          : table(x, x.node_alloc()) {}
-        hash_equivalent_table(hash_equivalent_table const& x,
-            value_allocator const& a)
-          : table(x, a) {}
-        hash_equivalent_table(hash_equivalent_table& x, move_tag m)
-          : table(x, m) {}
-        hash_equivalent_table(hash_equivalent_table& x,
-            value_allocator const& a, move_tag m)
-          : table(x, a, m) {}
-        ~hash_equivalent_table() {}
-
-        // Insert methods
-
-        iterator_base emplace_impl(node_constructor& a);
-        void emplace_impl_no_rehash(node_constructor& a);
-
-        // equals
-
-        bool equals(hash_equivalent_table const&) const;
-
-        inline node_ptr add_node(node_constructor& a,
-            bucket_ptr bucket, node_ptr pos);
-
-#if defined(BOOST_UNORDERED_STD_FORWARD)
-
-        template <class... Args>
-        iterator_base emplace(Args&&... args);
-
-#else
-
-#define BOOST_UNORDERED_INSERT_IMPL(z, n, _)                                   \
-        template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)>                         \
-        iterator_base emplace(BOOST_UNORDERED_FUNCTION_PARAMS(z, n));
-
-        BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_INSERT_IMPL, _)
-
-#undef BOOST_UNORDERED_INSERT_IMPL
-#endif
-
-        template <class I>
-        void insert_for_range(I i, I j, forward_traversal_tag);
-        template <class I>
-        void insert_for_range(I i, I j, boost::incrementable_traversal_tag);
-        template <class I>
-        void insert_range(I i, I j);
-    };
-
-    template <class H, class P, class A>
-    struct multiset : public types<
-        BOOST_DEDUCED_TYPENAME A::value_type,
-        BOOST_DEDUCED_TYPENAME A::value_type,
-        H, P, A,
-        set_extractor<BOOST_DEDUCED_TYPENAME A::value_type>,
-        grouped>
-    {
-        typedef hash_equivalent_table<multiset<H, P, A> > impl;
-        typedef hash_table<multiset<H, P, A> > table;
-    };
-
-    template <class K, class H, class P, class A>
-    struct multimap : public types<
-        K, BOOST_DEDUCED_TYPENAME A::value_type,
-        H, P, A,
-        map_extractor<K, BOOST_DEDUCED_TYPENAME A::value_type>,
-        grouped>
-    {
-        typedef hash_equivalent_table<multimap<K, H, P, A> > impl;
-        typedef hash_table<multimap<K, H, P, A> > table;
-    };
-
     ////////////////////////////////////////////////////////////////////////////
     // Equality
 

include/boost/unordered/detail/fwd.hpp

@@ -31,7 +31,7 @@
 // G = Grouped/Ungrouped
 // E = Key Extractor
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
 #   if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
         // STLport doesn't have std::forward.
 #   else
@@ -64,8 +64,6 @@ namespace boost { namespace unordered_detail {
     static const std::size_t default_bucket_count = 11;
     struct move_tag {};
 
-    template <class T> class hash_unique_table;
-    template <class T> class hash_equivalent_table;
     template <class Alloc, class Grouped>
     class hash_node_constructor;
     template <class ValueType>
@@ -569,9 +567,170 @@ namespace boost { namespace unordered_detail {
             node_constructor&, std::size_t);
     };
 
+    template <class T>
+    class hash_unique_table : public T::table
+    {
+    public:
+        typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
+        typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
+        typedef BOOST_DEDUCED_TYPENAME T::value_allocator value_allocator;
+        typedef BOOST_DEDUCED_TYPENAME T::key_type key_type;
+        typedef BOOST_DEDUCED_TYPENAME T::value_type value_type;
+        typedef BOOST_DEDUCED_TYPENAME T::table table;
+        typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor;
+
+        typedef BOOST_DEDUCED_TYPENAME T::node node;
+        typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr;
+        typedef BOOST_DEDUCED_TYPENAME T::bucket_ptr bucket_ptr;
+        typedef BOOST_DEDUCED_TYPENAME T::iterator_base iterator_base;
+        typedef BOOST_DEDUCED_TYPENAME T::extractor extractor;
+        
+        typedef std::pair<iterator_base, bool> emplace_return;
+
+        // Constructors
+
+        hash_unique_table(std::size_t n, hasher const& hf, key_equal const& eq,
+            value_allocator const& a)
+          : table(n, hf, eq, a) {}
+        hash_unique_table(hash_unique_table const& x)
+          : table(x, x.node_alloc()) {}
+        hash_unique_table(hash_unique_table const& x, value_allocator const& a)
+          : table(x, a) {}
+        hash_unique_table(hash_unique_table& x, move_tag m)
+          : table(x, m) {}
+        hash_unique_table(hash_unique_table& x, value_allocator const& a,
+            move_tag m)
+          : table(x, a, m) {}
+        ~hash_unique_table() {}
+
+        // Insert methods
+
+        emplace_return emplace_impl_with_node(node_constructor& a);
+        value_type& operator[](key_type const& k);
+
+        // equals
+
+        bool equals(hash_unique_table const&) const;
+
+        node_ptr add_node(node_constructor& a, bucket_ptr bucket);
+        
+#if defined(BOOST_UNORDERED_STD_FORWARD)
+
+        template<class... Args>
+        emplace_return emplace(Args&&... args);
+        template<class... Args>
+        emplace_return emplace_impl(key_type const& k, Args&&... args);
+        template<class... Args>
+        emplace_return emplace_impl(no_key, Args&&... args);
+        template<class... Args>
+        emplace_return emplace_empty_impl(Args&&... args);
+#else
+
+#define BOOST_UNORDERED_INSERT_IMPL(z, n, _)                                   \
+        template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)>                         \
+        emplace_return emplace(                                                \
+            BOOST_UNORDERED_FUNCTION_PARAMS(z, n));                            \
+        template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)>                         \
+        emplace_return emplace_impl(key_type const& k,                         \
+           BOOST_UNORDERED_FUNCTION_PARAMS(z, n));                             \
+        template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)>                         \
+        emplace_return emplace_impl(no_key,                                    \
+           BOOST_UNORDERED_FUNCTION_PARAMS(z, n));                             \
+        template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)>                         \
+        emplace_return emplace_empty_impl(                                     \
+           BOOST_UNORDERED_FUNCTION_PARAMS(z, n));
+
+        BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+            BOOST_UNORDERED_INSERT_IMPL, _)
+
+#undef BOOST_UNORDERED_INSERT_IMPL
+
+#endif
+
+        // if hash function throws, or inserting > 1 element, basic exception
+        // safety strong otherwise
+        template <class InputIt>
+        void insert_range(InputIt i, InputIt j);
+        template <class InputIt>
+        void insert_range_impl(key_type const&, InputIt i, InputIt j);
+        template <class InputIt>
+        void insert_range_impl(no_key, InputIt i, InputIt j);
+    };
+
+    template <class T>
+    class hash_equivalent_table : public T::table
+    {
+    public:
+        typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
+        typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
+        typedef BOOST_DEDUCED_TYPENAME T::value_allocator value_allocator;
+        typedef BOOST_DEDUCED_TYPENAME T::key_type key_type;
+        typedef BOOST_DEDUCED_TYPENAME T::value_type value_type;
+        typedef BOOST_DEDUCED_TYPENAME T::table table;
+        typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor;
+
+        typedef BOOST_DEDUCED_TYPENAME T::node node;
+        typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr;
+        typedef BOOST_DEDUCED_TYPENAME T::bucket_ptr bucket_ptr;
+        typedef BOOST_DEDUCED_TYPENAME T::iterator_base iterator_base;
+        typedef BOOST_DEDUCED_TYPENAME T::extractor extractor;
+
+        // Constructors
+
+        hash_equivalent_table(std::size_t n,
+            hasher const& hf, key_equal const& eq, value_allocator const& a)
+          : table(n, hf, eq, a) {}
+        hash_equivalent_table(hash_equivalent_table const& x)
+          : table(x, x.node_alloc()) {}
+        hash_equivalent_table(hash_equivalent_table const& x,
+            value_allocator const& a)
+          : table(x, a) {}
+        hash_equivalent_table(hash_equivalent_table& x, move_tag m)
+          : table(x, m) {}
+        hash_equivalent_table(hash_equivalent_table& x,
+            value_allocator const& a, move_tag m)
+          : table(x, a, m) {}
+        ~hash_equivalent_table() {}
+
+        // Insert methods
+
+        iterator_base emplace_impl(node_constructor& a);
+        void emplace_impl_no_rehash(node_constructor& a);
+
+        // equals
+
+        bool equals(hash_equivalent_table const&) const;
+
+        inline node_ptr add_node(node_constructor& a,
+            bucket_ptr bucket, node_ptr pos);
+
+#if defined(BOOST_UNORDERED_STD_FORWARD)
+
+        template <class... Args>
+        iterator_base emplace(Args&&... args);
+
+#else
+
+#define BOOST_UNORDERED_INSERT_IMPL(z, n, _)                                   \
+        template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)>                         \
+        iterator_base emplace(BOOST_UNORDERED_FUNCTION_PARAMS(z, n));
+
+        BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+            BOOST_UNORDERED_INSERT_IMPL, _)
+
+#undef BOOST_UNORDERED_INSERT_IMPL
+#endif
+
+        template <class I>
+        void insert_for_range(I i, I j, forward_traversal_tag);
+        template <class I>
+        void insert_for_range(I i, I j, boost::incrementable_traversal_tag);
+        template <class I>
+        void insert_range(I i, I j);
+    };
+
     // Iterator Access
 
-#if !defined(__clang__)
     class iterator_access
     {
     public:
@@ -582,28 +741,6 @@ namespace boost { namespace unordered_detail {
             return it.base_;
         }
     };
-#else
-    class iterator_access
-    {
-    public:
-        // Note: we access Iterator::base here, rather than in the function
-        // signature to work around a bug in the friend support of an
-        // early version of clang.
-
-        template <class Iterator>
-        struct base
-        {
-            typedef BOOST_DEDUCED_TYPENAME Iterator::base type;
-        };
-    
-        template <class Iterator>
-        static BOOST_DEDUCED_TYPENAME base<Iterator>::type const&
-            get(Iterator const& it)
-        {
-            return it.base_;
-        }
-    };
-#endif
 
     // Iterators
 
@@ -851,6 +988,52 @@ namespace boost { namespace unordered_detail {
 
         typedef std::pair<iterator_base, iterator_base> iterator_pair;
     };
+
+    template <class H, class P, class A>
+    struct set : public types<
+        BOOST_DEDUCED_TYPENAME A::value_type,
+        BOOST_DEDUCED_TYPENAME A::value_type,
+        H, P, A,
+        set_extractor<BOOST_DEDUCED_TYPENAME A::value_type>,
+        ungrouped>
+    {        
+        typedef hash_unique_table<set<H, P, A> > impl;
+        typedef hash_table<set<H, P, A> > table;
+    };
+
+    template <class H, class P, class A>
+    struct multiset : public types<
+        BOOST_DEDUCED_TYPENAME A::value_type,
+        BOOST_DEDUCED_TYPENAME A::value_type,
+        H, P, A,
+        set_extractor<BOOST_DEDUCED_TYPENAME A::value_type>,
+        grouped>
+    {
+        typedef hash_equivalent_table<multiset<H, P, A> > impl;
+        typedef hash_table<multiset<H, P, A> > table;
+    };
+
+    template <class K, class H, class P, class A>
+    struct map : public types<
+        K, BOOST_DEDUCED_TYPENAME A::value_type,
+        H, P, A,
+        map_extractor<K, BOOST_DEDUCED_TYPENAME A::value_type>,
+        ungrouped>
+    {
+        typedef hash_unique_table<map<K, H, P, A> > impl;
+        typedef hash_table<map<K, H, P, A> > table;
+    };
+
+    template <class K, class H, class P, class A>
+    struct multimap : public types<
+        K, BOOST_DEDUCED_TYPENAME A::value_type,
+        H, P, A,
+        map_extractor<K, BOOST_DEDUCED_TYPENAME A::value_type>,
+        grouped>
+    {
+        typedef hash_equivalent_table<multimap<K, H, P, A> > impl;
+        typedef hash_table<multimap<K, H, P, A> > table;
+    };
 }}
 
 #endif

include/boost/unordered/detail/table.hpp

@@ -12,7 +12,6 @@
 #include <algorithm>
 #include <boost/config/no_tr1/cmath.hpp>
 #include <boost/iterator/iterator_categories.hpp>
-#include <boost/throw_exception.hpp>
 
 #include <boost/unordered/detail/buckets.hpp>
 
@@ -609,15 +608,15 @@ namespace boost { namespace unordered_detail {
         hash_table<T>::at(key_type const& k) const
     {
         if(!this->size_)
-            boost::throw_exception(std::out_of_range("Unable to find key in unordered_map."));
+            throw std::out_of_range("Unable to find key in unordered_map.");
 
         bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
         node_ptr it = find_iterator(bucket, k);
 
-        if (!it)
-            boost::throw_exception(std::out_of_range("Unable to find key in unordered_map."));
-
-        return node::get_value(it);
+        if (BOOST_UNORDERED_BORLAND_BOOL(it))
+            return node::get_value(it);
+        else
+            throw std::out_of_range("Unable to find key in unordered_map.");
     }
 
     // equal_range

include/boost/unordered/detail/unique.hpp

@@ -12,119 +12,6 @@
 
 namespace boost { namespace unordered_detail {
 
-    template <class T>
-    class hash_unique_table : public T::table
-    {
-    public:
-        typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
-        typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
-        typedef BOOST_DEDUCED_TYPENAME T::value_allocator value_allocator;
-        typedef BOOST_DEDUCED_TYPENAME T::key_type key_type;
-        typedef BOOST_DEDUCED_TYPENAME T::value_type value_type;
-        typedef BOOST_DEDUCED_TYPENAME T::table table;
-        typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor;
-
-        typedef BOOST_DEDUCED_TYPENAME T::node node;
-        typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr;
-        typedef BOOST_DEDUCED_TYPENAME T::bucket_ptr bucket_ptr;
-        typedef BOOST_DEDUCED_TYPENAME T::iterator_base iterator_base;
-        typedef BOOST_DEDUCED_TYPENAME T::extractor extractor;
-        
-        typedef std::pair<iterator_base, bool> emplace_return;
-
-        // Constructors
-
-        hash_unique_table(std::size_t n, hasher const& hf, key_equal const& eq,
-            value_allocator const& a)
-          : table(n, hf, eq, a) {}
-        hash_unique_table(hash_unique_table const& x)
-          : table(x, x.node_alloc()) {}
-        hash_unique_table(hash_unique_table const& x, value_allocator const& a)
-          : table(x, a) {}
-        hash_unique_table(hash_unique_table& x, move_tag m)
-          : table(x, m) {}
-        hash_unique_table(hash_unique_table& x, value_allocator const& a,
-            move_tag m)
-          : table(x, a, m) {}
-        ~hash_unique_table() {}
-
-        // Insert methods
-
-        emplace_return emplace_impl_with_node(node_constructor& a);
-        value_type& operator[](key_type const& k);
-
-        // equals
-
-        bool equals(hash_unique_table const&) const;
-
-        node_ptr add_node(node_constructor& a, bucket_ptr bucket);
-        
-#if defined(BOOST_UNORDERED_STD_FORWARD)
-
-        template<class... Args>
-        emplace_return emplace(Args&&... args);
-        template<class... Args>
-        emplace_return emplace_impl(key_type const& k, Args&&... args);
-        template<class... Args>
-        emplace_return emplace_impl(no_key, Args&&... args);
-        template<class... Args>
-        emplace_return emplace_empty_impl(Args&&... args);
-#else
-
-#define BOOST_UNORDERED_INSERT_IMPL(z, n, _)                                   \
-        template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)>                         \
-        emplace_return emplace(                                                \
-            BOOST_UNORDERED_FUNCTION_PARAMS(z, n));                            \
-        template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)>                         \
-        emplace_return emplace_impl(key_type const& k,                         \
-           BOOST_UNORDERED_FUNCTION_PARAMS(z, n));                             \
-        template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)>                         \
-        emplace_return emplace_impl(no_key,                                    \
-           BOOST_UNORDERED_FUNCTION_PARAMS(z, n));                             \
-        template <BOOST_UNORDERED_TEMPLATE_ARGS(z, n)>                         \
-        emplace_return emplace_empty_impl(                                     \
-           BOOST_UNORDERED_FUNCTION_PARAMS(z, n));
-
-        BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
-            BOOST_UNORDERED_INSERT_IMPL, _)
-
-#undef BOOST_UNORDERED_INSERT_IMPL
-
-#endif
-
-        // if hash function throws, or inserting > 1 element, basic exception
-        // safety strong otherwise
-        template <class InputIt>
-        void insert_range(InputIt i, InputIt j);
-        template <class InputIt>
-        void insert_range_impl(key_type const&, InputIt i, InputIt j);
-        template <class InputIt>
-        void insert_range_impl(no_key, InputIt i, InputIt j);
-    };
-
-    template <class H, class P, class A>
-    struct set : public types<
-        BOOST_DEDUCED_TYPENAME A::value_type,
-        BOOST_DEDUCED_TYPENAME A::value_type,
-        H, P, A,
-        set_extractor<BOOST_DEDUCED_TYPENAME A::value_type>,
-        ungrouped>
-    {        
-        typedef hash_unique_table<set<H, P, A> > impl;
-        typedef hash_table<set<H, P, A> > table;
-    };
-
-    template <class K, class H, class P, class A>
-    struct map : public types<
-        K, BOOST_DEDUCED_TYPENAME A::value_type,
-        H, P, A,
-        map_extractor<K, BOOST_DEDUCED_TYPENAME A::value_type>,
-        ungrouped>
-    {
-        typedef hash_unique_table<map<K, H, P, A> > impl;
-        typedef hash_table<map<K, H, P, A> > table;
-    };
-
     ////////////////////////////////////////////////////////////////////////////
     // Equality
 

include/boost/unordered/detail/util.hpp

@@ -32,6 +32,12 @@ namespace boost { namespace unordered_detail {
     ////////////////////////////////////////////////////////////////////////////
     // primes
 
+    template<class T> struct prime_list_template
+    {
+        static std::size_t const value[];
+        static std::ptrdiff_t const length;
+    };
+
 #define BOOST_UNORDERED_PRIMES \
     (5ul)(11ul)(17ul)(29ul)(37ul)(53ul)(67ul)(79ul) \
     (97ul)(131ul)(193ul)(257ul)(389ul)(521ul)(769ul) \
@@ -41,28 +47,14 @@ namespace boost { namespace unordered_detail {
     (50331653ul)(100663319ul)(201326611ul)(402653189ul)(805306457ul) \
     (1610612741ul)(3221225473ul)(4294967291ul)
 
-    template<class T> struct prime_list_template
-    {
-        static std::size_t const value[];
-
-#if !defined(SUNPRO_CC)
-        static std::ptrdiff_t const length;
-#else
-        static std::ptrdiff_t const length
-            = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
-#endif
-    };
-
     template<class T>
     std::size_t const prime_list_template<T>::value[] = {
         BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIMES)
     };
 
-#if !defined(SUNPRO_CC)
     template<class T>
     std::ptrdiff_t const prime_list_template<T>::length
         = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
-#endif
 
 #undef BOOST_UNORDERED_PRIMES
 

include/boost/unordered/unordered_map.hpp

@@ -19,7 +19,7 @@
 #include <boost/unordered/detail/equivalent.hpp>
 #include <boost/unordered/detail/unique.hpp>
 
-#if defined(BOOST_NO_RVALUE_REFERENCES)
+#if !defined(BOOST_HAS_RVALUE_REFS)
 #include <boost/unordered/detail/move.hpp>
 #endif
 
@@ -159,7 +159,7 @@ namespace boost
 
         ~unordered_map() {}
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
+#if defined(BOOST_HAS_RVALUE_REFS)
         unordered_map(unordered_map&& other)
           : table_(other.table_, boost::unordered_detail::move_tag())
         {
@@ -369,11 +369,6 @@ namespace boost
             return iterator(table_.erase_range(get(first), get(last)));
         }
 
-        void quick_erase(const_iterator position)
-        {
-            table_.erase(get(position));
-        }
-
         void erase_return_void(const_iterator position)
         {
             table_.erase(get(position));
@@ -704,7 +699,7 @@ namespace boost
 
         ~unordered_multimap() {}
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
+#if defined(BOOST_HAS_RVALUE_REFS)
         unordered_multimap(unordered_multimap&& other)
           : table_(other.table_, boost::unordered_detail::move_tag())
         {
@@ -912,11 +907,6 @@ namespace boost
             return iterator(table_.erase_range(get(first), get(last)));
         }
 
-        void quick_erase(const_iterator position)
-        {
-            table_.erase(get(position));
-        }
-
         void erase_return_void(const_iterator position)
         {
             table_.erase(get(position));

include/boost/unordered/unordered_set.hpp

@@ -19,7 +19,7 @@
 #include <boost/unordered/detail/equivalent.hpp>
 #include <boost/unordered/detail/unique.hpp>
 
-#if defined(BOOST_NO_RVALUE_REFERENCES)
+#if !defined(BOOST_HAS_RVALUE_REFS)
 #include <boost/unordered/detail/move.hpp>
 #endif
 
@@ -153,7 +153,7 @@ namespace boost
         
         ~unordered_set() {}
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
+#if defined(BOOST_HAS_RVALUE_REFS)
         unordered_set(unordered_set&& other)
           : table_(other.table_, boost::unordered_detail::move_tag())
         {
@@ -361,11 +361,6 @@ namespace boost
             return iterator(table_.erase_range(get(first), get(last)));
         }
 
-        void quick_erase(const_iterator position)
-        {
-            table_.erase(get(position));
-        }
-
         void erase_return_void(const_iterator position)
         {
             table_.erase(get(position));
@@ -650,7 +645,7 @@ namespace boost
 
         ~unordered_multiset() {}
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
+#if defined(BOOST_HAS_RVALUE_REFS)
         unordered_multiset(unordered_multiset&& other)
           : table_(other.table_, boost::unordered_detail::move_tag())
         {
@@ -854,11 +849,6 @@ namespace boost
             return iterator(table_.erase_range(get(first), get(last)));
         }
 
-        void quick_erase(const_iterator position)
-        {
-            table_.erase(get(position));
-        }
-
         void erase_return_void(const_iterator position)
         {
             table_.erase(get(position));

test/exception/Jamfile.v2

@@ -15,7 +15,7 @@ project unordered-test/exception-tests
         <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
         <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
         <toolset>gcc:<define>_GLIBCXX_DEBUG
-        #<toolset>darwin:<define>_GLIBCXX_DEBUG
+        <toolset>darwin:<define>_GLIBCXX_DEBUG
         <toolset>msvc:<warnings-as-errors>on
         #<toolset>gcc:<warnings-as-errors>on
         #<toolset>darwin:<warnings-as-errors>on

test/exception/constructor_exception_tests.cpp

@@ -9,8 +9,6 @@
 #include "../helpers/random_values.hpp"
 #include "../helpers/input_iterator.hpp"
 
-template <typename T> inline void avoid_unused_warning(T const&) {}
-
 test::seed_t seed(91274);
 
 struct objects
@@ -26,7 +24,6 @@ struct construct_test1 : public objects, test::exception_base
 {
     void run() const {
         T x;
-        avoid_unused_warning(x);
     }
 };
 
@@ -35,7 +32,6 @@ struct construct_test2 : public objects, test::exception_base
 {
     void run() const {
         T x(300);
-        avoid_unused_warning(x);
     }
 };
 
@@ -44,7 +40,6 @@ struct construct_test3 : public objects, test::exception_base
 {
     void run() const {
         T x(0, hash);
-        avoid_unused_warning(x);
     }
 };
 
@@ -53,7 +48,6 @@ struct construct_test4 : public objects, test::exception_base
 {
     void run() const {
         T x(0, hash, equal_to);
-        avoid_unused_warning(x);
     }
 };
 
@@ -62,7 +56,6 @@ struct construct_test5 : public objects, test::exception_base
 {
     void run() const {
         T x(50, hash, equal_to, allocator);
-        avoid_unused_warning(x);
     }
 };
 
@@ -71,7 +64,6 @@ struct construct_test6 : public objects, test::exception_base
 {
     void run() const {
         T x(allocator);
-        avoid_unused_warning(x);
     }
 };
 
@@ -89,7 +81,6 @@ struct range_construct_test1 : public range<T>, objects
 {
     void run() const {
         T x(this->values.begin(), this->values.end());
-        avoid_unused_warning(x);
     }
 };
 
@@ -98,7 +89,6 @@ struct range_construct_test2 : public range<T>, objects
 {
     void run() const {
         T x(this->values.begin(), this->values.end(), 0);
-        avoid_unused_warning(x);
     }
 };
 
@@ -107,7 +97,6 @@ struct range_construct_test3 : public range<T>, objects
 {
     void run() const {
         T x(this->values.begin(), this->values.end(), 0, hash);
-        avoid_unused_warning(x);
     }
 };
 
@@ -116,7 +105,6 @@ struct range_construct_test4 : public range<T>, objects
 {
     void run() const {
         T x(this->values.begin(), this->values.end(), 100, hash, equal_to);
-        avoid_unused_warning(x);
     }
 };
 
@@ -130,7 +118,6 @@ struct range_construct_test5 : public range<T>, objects
     void run() const {
         T x(this->values.begin(), this->values.end(), 0,
             hash, equal_to, allocator);
-        avoid_unused_warning(x);
     }
 };
 
@@ -144,7 +131,6 @@ struct input_range_construct_test : public range<T>, objects
             begin = this->values.begin(), end = this->values.end();
         T x(test::input_iterator(begin), test::input_iterator(end),
                 0, hash, equal_to, allocator);
-        avoid_unused_warning(x);
     }
 };
 

test/exception/copy_exception_tests.cpp

@@ -8,8 +8,6 @@
 #include "./containers.hpp"
 #include "../helpers/random_values.hpp"
 
-template <typename T> inline void avoid_unused_warning(T const&) {}
-
 test::seed_t seed(73041);
 
 template <class T>
@@ -19,7 +17,6 @@ struct copy_test1 : public test::exception_base
 
     void run() const {
         T y(x);
-        avoid_unused_warning(y);
     }
 };
 
@@ -33,7 +30,6 @@ struct copy_test2 : public test::exception_base
 
     void run() const {
         T y(x);
-        avoid_unused_warning(y);
     }
 };
 
@@ -47,7 +43,6 @@ struct copy_test3 : public test::exception_base
 
     void run() const {
         T y(x);
-        avoid_unused_warning(y);
     }
 };
 
@@ -62,7 +57,6 @@ struct copy_with_allocator_test : public test::exception_base
 
     void run() const {
         T y(x, allocator);
-        avoid_unused_warning(y);
     }
 };
 

test/exception/insert_exception_tests.cpp

@@ -39,7 +39,7 @@ struct insert_test_base : public test::exception_base
     }
 };
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
 
 template <class T>
 struct emplace_test1 : public insert_test_base<T>
@@ -238,7 +238,7 @@ struct insert_test_rehash3 : public insert_test_base<T>
     (insert_test1)(insert_test2)(insert_test3)(insert_test4) \
     (insert_test_rehash1)(insert_test_rehash2)(insert_test_rehash3)
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
 #define ALL_TESTS (emplace_test1)BASIC_TESTS
 #else
 #define ALL_TESTS BASIC_TESTS

test/helpers/list.hpp

@@ -94,7 +94,7 @@ namespace test
 
             node* ptr_;
         public:
-            list_iterator() : ptr_(0) {}
+            list_iterator() : ptr_(0) {};
             explicit list_iterator(node* x) : ptr_(x) {}
 
             T& operator*() const { return ptr_->value_; }

test/unordered/Jamfile.v2

@@ -12,7 +12,7 @@ project unordered-test/unordered
         <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
         <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter"
         <toolset>gcc:<define>_GLIBCXX_DEBUG
-        #<toolset>darwin:<define>_GLIBCXX_DEBUG
+        <toolset>darwin:<define>_GLIBCXX_DEBUG
         <toolset>msvc:<warnings-as-errors>on
         #<toolset>gcc:<warnings-as-errors>on
         #<toolset>darwin:<warnings-as-errors>on

test/unordered/compile_tests.hpp

@@ -138,12 +138,6 @@ void container_test(X& r, T const&)
 
     typedef BOOST_DEDUCED_TYPENAME X::allocator_type allocator_type;
     test::check_return_type<allocator_type>::equals(a_const.get_allocator());
-    
-    // Avoid unused variable warnings:
-
-    sink(u);
-    sink(u2);
-    sink(u3);
 }
 
 template <class X, class Key>
@@ -381,16 +375,4 @@ void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
     test::check_return_type<float>::equals(b.max_load_factor());
     a.max_load_factor((float) 2.0);
     a.rehash(100);
-    
-    // Avoid unused variable warnings:
-
-    sink(a);
-    sink(a2);
-    sink(a3);
-    sink(a4);
-    sink(a5);
-    sink(a6);
-    sink(a7);
-    sink(a8);
-    sink(a9);
 }

test/unordered/constructor_tests.cpp

@@ -142,6 +142,7 @@ void constructor_tests1(T*,
 
     std::cerr<<"Construct 11\n";
     {
+        test::random_values<T> v(1000, generator);
         T x(al);
         BOOST_TEST(x.empty());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));

test/unordered/erase_tests.cpp

@@ -116,7 +116,7 @@ void erase_tests1(Container*,
         BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin());
     }
 
-    std::cerr<<"quick_erase(begin()).\n";
+    std::cerr<<"erase_return_void(begin()).\n";
     {
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
@@ -126,7 +126,7 @@ void erase_tests1(Container*,
             BOOST_DEDUCED_TYPENAME Container::key_type
                 key = test::get_key<Container>(*x.begin());
             std::size_t count = x.count(key);
-            x.quick_erase(x.begin());
+            x.erase_return_void(x.begin());
             --size;
             BOOST_TEST(x.count(key) == count - 1);
             BOOST_TEST(x.size() == size);
@@ -134,7 +134,7 @@ void erase_tests1(Container*,
         BOOST_TEST(x.empty());
     }
 
-    std::cerr<<"quick_erase(random position).\n";
+    std::cerr<<"erase_return_void(random position).\n";
     {
         test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
@@ -155,7 +155,7 @@ void erase_tests1(Container*,
             BOOST_DEDUCED_TYPENAME Container::key_type
                 key = test::get_key<Container>(*pos);
             std::size_t count = x.count(key);
-            x.quick_erase(pos);
+            x.erase_return_void(pos);
             --size;
             if(size > 0)
                 BOOST_TEST(index == 0 ? next == x.begin() :

test/unordered/fwd_set_test.cpp

@@ -57,7 +57,8 @@ UNORDERED_AUTO_TEST(use_fwd_declared_trait) {
     boost::unordered_set<int> x;
     BOOST_TEST(sizeof(is_unordered_set_impl(&x)) == sizeof(true_type));
 
-    BOOST_TEST(sizeof(is_unordered_set_impl((int*) 0)) == sizeof(false_type));
+    int dummy;
+    BOOST_TEST(sizeof(is_unordered_set_impl(&dummy)) == sizeof(false_type));
 }
 
 UNORDERED_AUTO_TEST(use_set_fwd_declared_function) {

test/unordered/insert_tests.cpp

@@ -231,7 +231,7 @@ void insert_tests2(X*,
     }
 }
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
 
 template <class X>
 void unique_emplace_tests1(X*,
@@ -403,7 +403,7 @@ UNORDERED_TEST(insert_tests2,
     ((default_generator)(generate_collisions))
 )
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
 UNORDERED_TEST(unique_emplace_tests1,
     ((test_set)(test_map))
     ((default_generator)(generate_collisions))

test/unordered/move_tests.cpp

@@ -134,7 +134,7 @@ namespace move_tests
         {
             test::random_values<T> v(25, generator);
             T y(create(v, count, hf, eq, al, 1.0), al);
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
+#if defined(BOOST_HAS_RVALUE_REFS)
             BOOST_TEST(count == test::global_object_count);
 #else
             BOOST_TEST(

test/unordered/unnecessary_copy_tests.cpp

@@ -31,7 +31,7 @@ namespace unnecessary_copy_tests
             : tag_(x.tag_) { ++copies; }
 
         count_copies(count_copies const& x) : tag_(x.tag_) { ++copies; }
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
+#if defined(BOOST_HAS_RVALUE_REFS)
         count_copies(count_copies&& x) : tag_(x.tag_) {
             x.tag_ = -1; ++moves;
         }
@@ -136,7 +136,7 @@ namespace unnecessary_copy_tests
         reset();
         T x;
         x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
-#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
         COPY_COUNT(1);
 #else
         COPY_COUNT(2);
@@ -148,7 +148,7 @@ namespace unnecessary_copy_tests
     UNORDERED_TEST(unnecessary_copy_emplace_rvalue_test,
             ((set)(multiset)(map)(multimap)))
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
     template <class T>
     void unnecessary_copy_emplace_move_test(T*)
     {
@@ -199,7 +199,7 @@ namespace unnecessary_copy_tests
         x.emplace(source<count_copies>());
         COPY_COUNT(1); MOVE_COUNT(0);
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
+#if defined(BOOST_HAS_RVALUE_REFS)
         // No move should take place.
         reset();
         x.emplace(std::move(a));
@@ -271,7 +271,7 @@ namespace unnecessary_copy_tests
         //x.emplace(a_ref);
         //COPY_COUNT(0); MOVE_COUNT(0);
 
-#if !defined(BOOST_NO_RVALUE_REFERENCES)
+#if defined(BOOST_HAS_RVALUE_REFS)
         // No move should take place.
         // (since a is already in the container)
         reset();