Release 1.37.0

[SVN r51178]

CMakeLists.txt

@@ -0,0 +1,23 @@
+#----------------------------------------------------------------------------
+# This file was automatically generated from the original CMakeLists.txt file
+# Add a variable to hold the headers for the library
+set (lib_headers
+    unordered_map.hpp
+    unordered_set.hpp
+    unordered
+)
+
+# Add a library target to the build system
+boost_library_project(
+  unordered
+  #  SRCDIRS 
+  #  TESTDIRS 
+  HEADERS ${lib_headers}
+  #  DOCDIRS 
+  #  DESCRIPTION 
+  MODULARIZED 
+  #  AUTHORS 
+  #  MAINTAINERS 
+)
+
+

doc/changes.qbk

@@ -33,4 +33,33 @@ First official release.
   are available.
 * Added equality operators.
 
+[h2 Boost 1.37.0]
+
+* Rename overload of `emplace` with hint, to `emplace_hint` as specified in
+  [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2691.pdf n2691].
+* Provide forwarding headers at `<boost/unordered/unordered_map_fwd.hpp>` and
+  `<boost/unordered/unordered_set_fwd.hpp>`.
+* Move all the implementation inside `boost/unordered`, to assist
+  modularization and hopefully make it easier to track changes in subversion.
+
+[h2 Boost 1.38.0]
+
+* Use [@../../libs/utility/swap.html `boost::swap`].
+* [@https://svn.boost.org/trac/boost/ticket/2237 Ticket 2237]:
+  Document that the equality and inequality operators are undefined for two
+  objects if their equality predicates aren't equivalent. Thanks to Daniel
+  Krügler.
+* [@https://svn.boost.org/trac/boost/ticket/1710 Ticket 1710]: 
+  Use a larger prime number list. Thanks to Thorsten Ottosen and Hervé
+  Brönnimann.
+* Use
+  [@../../libs/type_traits/doc/html/boost_typetraits/category/alignment.html
+  aligned storage] to store the types. This changes the way the allocator is
+  used to construct nodes. It used to construct the node with two calls to
+  the allocator's `construct` method - once for the pointers and once for the
+  value. It now constructs the node with a single call to construct and
+  then constructs the value using in place construction.
+* Add support for C++0x initializer lists where they're available (currently
+  only g++ 4.4 in C++0x mode).
+
 [endsect]

doc/hash_equality.qbk

@@ -41,6 +41,16 @@ This is a simplified version of the example at
 [@../../libs/unordered/examples/case_insensitive.hpp /libs/unordered/examples/case_insensitive.hpp]
 which supports other locales and string types.
 
+[caution
+Be careful when using the equality (`==`) operator with custom equality
+predicates, especially if you're using a function pointer. If you compare two
+containers with different equality predicates then the result is undefined.
+For most stateless function objects this is impossible - since you can only
+compare objects with the same equality predicate you know the equality
+predicates must be equal. But if you're using function pointers or a stateful
+equality predicate (e.g. boost::function) then you can get into trouble.
+]
+
 [h2 Custom Types]
 
 Similarly, a custom hash function can be used for custom types:

doc/intro.qbk

@@ -9,7 +9,7 @@
     [@http://www.boost.org/doc/html/boost_tr1.html
     Boost.TR1]]
 [def __draft__
-    [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2461.pdf
+    [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2691.pdf
     Working Draft of the C++ Standard]]
 [def __hash-table__ [@http://en.wikipedia.org/wiki/Hash_table
     hash table]]

doc/ref.xml

@@ -24,7 +24,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
           </purpose>
           <description>
             <para>For the normative reference see chapter 23 of
-              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">the working draft of the C++ standard [n2461].</ulink></para>
+              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
             <para><emphasis role="bold">Template Parameters</emphasis>
               <informaltable>
                 <tgroup cols="2">
@@ -287,7 +287,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                 <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
               </notes>
             </method>
-            <method name="emplace">
+            <method name="emplace_hint">
               <template>
                 <template-type-parameter name="Args" pack="1">
                 </template-type-parameter>
@@ -678,6 +678,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <type>bool</type>
               <notes>
                 <para>This is a boost extension.</para>
+                <para>Behavior is undefined if the two containers don't have
+                    equivalent equality predicates.</para>
               </notes>
             </function>
             <function name="operator!=">
@@ -700,6 +702,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <type>bool</type>
               <notes>
                 <para>This is a boost extension.</para>
+                <para>Behavior is undefined if the two containers don't have
+                    equivalent equality predicates.</para>
               </notes>
             </function>
           </free-function-group>
@@ -754,7 +758,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
           </purpose>
           <description>
             <para>For the normative reference see chapter 23 of
-              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">the working draft of the C++ standard [n2461].</ulink></para>
+              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
             <para><emphasis role="bold">Template Parameters</emphasis>
               <informaltable>
                 <tgroup cols="2">
@@ -1016,7 +1020,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                 <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
               </notes>
             </method>
-            <method name="emplace">
+            <method name="emplace_hint">
               <template>
                 <template-type-parameter name="Args" pack="1">
                 </template-type-parameter>
@@ -1406,6 +1410,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <type>bool</type>
               <notes>
                 <para>This is a boost extension.</para>
+                <para>Behavior is undefined if the two containers don't have
+                    equivalent equality predicates.</para>
               </notes>
             </function>
             <function name="operator!=">
@@ -1428,6 +1434,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <type>bool</type>
               <notes>
                 <para>This is a boost extension.</para>
+                <para>Behavior is undefined if the two containers don't have
+                    equivalent equality predicates.</para>
               </notes>
             </function>
           </free-function-group>
@@ -1488,7 +1496,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
           </purpose>
           <description>
             <para>For the normative reference see chapter 23 of
-              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">the working draft of the C++ standard [n2461].</ulink></para>
+              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
             <para><emphasis role="bold">Template Parameters</emphasis>
               <informaltable>
                 <tgroup cols="2">
@@ -1757,7 +1765,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                 <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
               </notes>
             </method>
-            <method name="emplace">
+            <method name="emplace_hint">
               <template>
                 <template-type-parameter name="Args" pack="1">
                 </template-type-parameter>
@@ -2185,6 +2193,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <type>bool</type>
               <notes>
                 <para>This is a boost extension.</para>
+                <para>Behavior is undefined if the two containers don't have
+                    equivalent equality predicates.</para>
               </notes>
             </function>
             <function name="operator!=">
@@ -2209,6 +2219,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <type>bool</type>
               <notes>
                 <para>This is a boost extension.</para>
+                <para>Behavior is undefined if the two containers don't have
+                    equivalent equality predicates.</para>
               </notes>
             </function>
           </free-function-group>
@@ -2267,7 +2279,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
           </purpose>
           <description>
             <para>For the normative reference see chapter 23 of
-              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">the working draft of the C++ standard [n2461].</ulink></para>
+              <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
             <para><emphasis role="bold">Template Parameters</emphasis>
               <informaltable>
                 <tgroup cols="2">
@@ -2535,7 +2547,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                 <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
               </notes>
             </method>
-            <method name="emplace">
+            <method name="emplace_hint">
               <template>
                 <template-type-parameter name="Args" pack="1">
                 </template-type-parameter>
@@ -2927,6 +2939,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <type>bool</type>
               <notes>
                 <para>This is a boost extension.</para>
+                <para>Behavior is undefined if the two containers don't have
+                    equivalent equality predicates.</para>
               </notes>
             </function>
             <function name="operator!=">
@@ -2951,6 +2965,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
               <type>bool</type>
               <notes>
                 <para>This is a boost extension.</para>
+                <para>Behavior is undefined if the two containers don't have
+                    equivalent equality predicates.</para>
               </notes>
             </function>
           </free-function-group>

include/boost/unordered/detail/hash_table.hpp

@@ -14,7 +14,7 @@
 #include <boost/config.hpp>
 
 #include <cstddef>
-#include <cmath>
+#include <boost/config/no_tr1/cmath.hpp>
 #include <algorithm>
 #include <utility>
 #include <stdexcept>
@@ -26,9 +26,12 @@
 #include <boost/static_assert.hpp>
 #include <boost/unordered/detail/allocator_helpers.hpp>
 #include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/type_traits/alignment_of.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/utility/swap.hpp>
 
 #include <boost/mpl/aux_/config/eti.hpp>
 
@@ -58,17 +61,6 @@ namespace boost {
         static const std::size_t default_initial_bucket_count = 50;
         static const float minimum_max_load_factor = 1e-3f;
 
-        template <class T>
-        inline void hash_swap(T& x, T& y)
-        {
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-            std::swap(x,y);
-#else
-            using std::swap;
-            swap(x, y);
-#endif
-        }
-
         inline std::size_t double_to_size_t(double f)
         {
             return f >= static_cast<double>((std::numeric_limits<std::size_t>::max)()) ?
@@ -86,8 +78,9 @@ namespace boost {
 
         template<typename T>
         std::size_t const prime_list_template<T>::value[] = {
-            53ul, 97ul, 193ul, 389ul, 769ul,
-            1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
+            5ul, 11ul, 17ul, 29ul, 37ul, 53ul, 67ul, 79ul,
+            97ul, 131ul, 193ul, 257ul, 389ul, 521ul, 769ul,
+            1031ul, 1543ul, 2053ul, 3079ul, 6151ul, 12289ul, 24593ul,
             49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
             1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
             50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
@@ -230,7 +223,11 @@ namespace boost {
             functions func2_;
             functions_ptr func_; // The currently active functions.
         };
-
+        
+        template <typename T>
+        void destroy(T* x) {
+            x->~T();
+        }
     }
 }
 

include/boost/unordered/detail/hash_table_impl.hpp

@@ -34,7 +34,6 @@ namespace boost {
         public:
             typedef BOOST_UNORDERED_TABLE_DATA data;
 
-            struct node_base;
             struct node;
             struct bucket;
             typedef std::size_t size_type;
@@ -45,9 +44,6 @@ namespace boost {
             typedef BOOST_DEDUCED_TYPENAME
                 boost::unordered_detail::rebind_wrap<Alloc, node>::type
                 node_allocator;
-            typedef BOOST_DEDUCED_TYPENAME
-                boost::unordered_detail::rebind_wrap<Alloc, node_base>::type
-                node_base_allocator;
             typedef BOOST_DEDUCED_TYPENAME
                 boost::unordered_detail::rebind_wrap<Alloc, bucket>::type
                 bucket_allocator;
@@ -88,39 +84,36 @@ namespace boost {
                 }
             };
 
+            // Value Base
+
+            struct value_base {
+                typename boost::aligned_storage<
+                    sizeof(value_type),
+                    boost::alignment_of<value_type>::value>::type data_;
+
+                void* address() { return this; }
+            };
+
             // Hash Node
             //
             // all no throw
 
-            struct node_base : bucket
-            {
+            struct node : value_base, bucket {
 #if BOOST_UNORDERED_EQUIVALENT_KEYS
             public:
-                node_base() : group_prev_()
+                node() : group_prev_()
                 {
                     BOOST_UNORDERED_MSVC_RESET_PTR(group_prev_);
                 }
 
                 link_ptr group_prev_;
 #endif
+
+                value_type& value() {
+                    return *static_cast<value_type*>(this->address());
+                }
             };
 
-            struct node : node_base
-            {
-            public:
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-                template <typename... Args>
-                node(Args&&... args)
-                    : node_base(), value_(std::forward<Args>(args)...) {}
-#else
-                node(value_type const& v) : node_base(), value_(v) {}
-#endif
-
-                value_type value_;
-            };
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-
             // allocators
             //
             // Stores all the allocators that we're going to need.
@@ -136,15 +129,17 @@ namespace boost {
 
                 void destroy(link_ptr ptr)
                 {
-                    node_ptr n(node_alloc_.address(*static_cast<node*>(&*ptr)));
+                    node* raw_ptr = static_cast<node*>(&*ptr);
+                    boost::unordered_detail::destroy(&raw_ptr->value());
+                    node_ptr n(node_alloc_.address(*raw_ptr));
                     node_alloc_.destroy(n);
                     node_alloc_.deallocate(n, 1);
                 }
 
                 void swap(allocators& x)
                 {
-                    unordered_detail::hash_swap(node_alloc_, x.node_alloc_);
-                    unordered_detail::hash_swap(bucket_alloc_, x.bucket_alloc_);
+                    boost::swap(node_alloc_, x.node_alloc_);
+                    boost::swap(bucket_alloc_, x.bucket_alloc_);
                 }
 
                 bool operator==(allocators const& x)
@@ -163,146 +158,62 @@ namespace boost {
 
                 node_ptr node_;
                 bool node_constructed_;
+                bool value_constructed_;
 
             public:
 
                 node_constructor(allocators& a)
                     : allocators_(a),
-                    node_(), node_constructed_(false)
+                    node_(), node_constructed_(false), value_constructed_(false)
                 {
                 }
 
                 ~node_constructor()
                 {
                     if (node_) {
+                        if (value_constructed_) {
+                            boost::unordered_detail::destroy(&node_->value());
+                        }
+
                         if (node_constructed_)
                             allocators_.node_alloc_.destroy(node_);
                         allocators_.node_alloc_.deallocate(node_, 1);
                     }
                 }
 
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
                 template <typename... Args>
                 void construct(Args&&... args)
                 {
                     BOOST_ASSERT(!node_);
                     node_constructed_ = false;
+                    value_constructed_ = false;
 
                     node_ = allocators_.node_alloc_.allocate(1);
-                    allocators_.node_alloc_.construct(node_, std::forward<Args>(args)...);
+
+                    allocators_.node_alloc_.construct(node_, node());
                     node_constructed_ = true;
-                }
 
-                node_ptr get() const
-                {
-                    BOOST_ASSERT(node_);
-                    return node_;
+                    new(node_->address()) value_type(std::forward<Args>(args)...);
+                    value_constructed_ = true;
                 }
-
-                // no throw
-                link_ptr release()
-                {
-                    node_ptr p = node_;
-                    unordered_detail::reset(node_);
-                    return link_ptr(allocators_.bucket_alloc_.address(*p));
-                }
-
-            private:
-                node_constructor(node_constructor const&);
-                node_constructor& operator=(node_constructor const&);
-            };
 #else
-
-            // allocators
-            //
-            // Stores all the allocators that we're going to need.
-
-            struct allocators
-            {
-                node_allocator node_alloc_;
-                bucket_allocator bucket_alloc_;
-                value_allocator value_alloc_;
-                node_base_allocator node_base_alloc_;
-
-                allocators(value_allocator const& a)
-                    : node_alloc_(a), bucket_alloc_(a),
-                    value_alloc_(a), node_base_alloc_(a)
-                {}
-
-                void destroy(link_ptr ptr)
-                {
-                    node_ptr n(node_alloc_.address(*static_cast<node*>(&*ptr)));
-                    value_alloc_.destroy(value_alloc_.address(n->value_));
-                    node_base_alloc_.destroy(node_base_alloc_.address(*n));
-                    node_alloc_.deallocate(n, 1);
-                }
-
-                void swap(allocators& x)
-                {
-                    unordered_detail::hash_swap(node_alloc_, x.node_alloc_);
-                    unordered_detail::hash_swap(bucket_alloc_, x.bucket_alloc_);
-                    unordered_detail::hash_swap(value_alloc_, x.value_alloc_);
-                    unordered_detail::hash_swap(node_base_alloc_, x.node_base_alloc_);
-                }
-
-                bool operator==(allocators const& x)
-                {
-                    return value_alloc_ == x.value_alloc_;
-                }
-            };
-
-            // node_constructor
-            //
-            // Used to construct nodes in an exception safe manner.
-
-            class node_constructor
-            {
-                allocators& allocators_;
-
-                node_ptr node_;
-                bool value_constructed_;
-                bool node_base_constructed_;
-
-            public:
-
-                node_constructor(allocators& a)
-                    : allocators_(a),
-                    node_(), value_constructed_(false), node_base_constructed_(false)
-                {
-                    BOOST_UNORDERED_MSVC_RESET_PTR(node_);
-                }
-
-                ~node_constructor()
-                {
-                    if (node_) {
-                        if (value_constructed_)
-                            allocators_.value_alloc_.destroy(
-                                allocators_.value_alloc_.address(node_->value_));
-                        if (node_base_constructed_)
-                            allocators_.node_base_alloc_.destroy(
-                                allocators_.node_base_alloc_.address(*node_));
-
-                        allocators_.node_alloc_.deallocate(node_, 1);
-                    }
-                }
-
                 template <typename V>
                 void construct(V const& v)
                 {
                     BOOST_ASSERT(!node_);
+                    node_constructed_ = false;
                     value_constructed_ = false;
-                    node_base_constructed_ = false;
 
                     node_ = allocators_.node_alloc_.allocate(1);
 
-                    allocators_.node_base_alloc_.construct(
-                            allocators_.node_base_alloc_.address(*node_),
-                            node_base());
-                    node_base_constructed_ = true;
+                    allocators_.node_alloc_.construct(node_, node());
+                    node_constructed_ = true;
 
-                    allocators_.value_alloc_.construct(
-                            allocators_.value_alloc_.address(node_->value_), v);
+                    new(node_->address()) value_type(v);
                     value_constructed_ = true;
                 }
+#endif
 
                 node_ptr get() const
                 {
@@ -322,7 +233,6 @@ namespace boost {
                 node_constructor(node_constructor const&);
                 node_constructor& operator=(node_constructor const&);
             };
-#endif
 
             // Methods for navigating groups of elements with equal keys.
 
@@ -351,8 +261,7 @@ namespace boost {
 
             // pre: Must be pointing to a node
             static inline reference get_value(link_ptr p) {
-                BOOST_ASSERT(p);
-                return static_cast<node*>(&*p)->value_;
+                return get_node(p).value();
             }
 
             class iterator_base
@@ -1357,17 +1266,10 @@ namespace boost {
             // accessors
 
             // no throw
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
             node_allocator get_allocator() const
             {
                 return data_.allocators_.node_alloc_;
             }
-#else
-            value_allocator get_allocator() const
-            {
-                return data_.allocators_.value_alloc_;
-            }
-#endif
 
             // no throw
             hasher const& hash_function() const
@@ -1469,6 +1371,21 @@ namespace boost {
                 return need_to_reserve;
             }
 
+            // basic exception safety
+            bool reserve_for_insert(size_type n)
+            {
+                bool need_to_reserve = n >= max_load_;
+                // throws - basic:
+                if (need_to_reserve) {
+                    size_type s = size();
+                    s = s + (s >> 1);
+                    s = s > n ? s : n;
+                    rehash_impl(min_buckets_for_size(s));
+                }
+                BOOST_ASSERT(n < max_load_ || n > max_size());
+                return need_to_reserve;
+            }
+
         public:
 
             // no throw
@@ -1713,14 +1630,14 @@ namespace boost {
 
             iterator_base insert_impl(node_constructor& a)
             {
-                key_type const& k = extract_key(a.get()->value_);
+                key_type const& k = extract_key(a.get()->value());
                 size_type hash_value = hash_function()(k);
                 bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value);
                 link_ptr position = find_iterator(bucket, k);
 
                 // reserve has basic exception safety if the hash function
                 // throws, strong otherwise.
-                if(reserve(size() + 1))
+                if(reserve_for_insert(size() + 1))
                     bucket = data_.bucket_ptr_from_hash(hash_value);
 
                 // I'm relying on link_ptr not being invalidated by
@@ -1735,7 +1652,7 @@ namespace boost {
             iterator_base insert_hint_impl(iterator_base const& it, node_constructor& a)
             {
                 // equal can throw, but with no effects
-                if (it == data_.end() || !equal(extract_key(a.get()->value_), *it)) {
+                if (it == data_.end() || !equal(extract_key(a.get()->value()), *it)) {
                     // Use the standard insert if the iterator doesn't point
                     // to a matching key.
                     return insert_impl(a);
@@ -1750,8 +1667,8 @@ namespace boost {
 
                     // reserve has basic exception safety if the hash function
                     // throws, strong otherwise.
-                    bucket_ptr base = reserve(size() + 1) ?
-                        get_bucket(extract_key(a.get()->value_)) : it.bucket_;
+                    bucket_ptr base = reserve_for_insert(size() + 1) ?
+                        get_bucket(extract_key(a.get()->value())) : it.bucket_;
 
                     // Nothing after this point can throw
 
@@ -1775,13 +1692,13 @@ namespace boost {
                 }
                 else {
                     // Only require basic exception safety here
-                    reserve(size() + distance);
+                    reserve_for_insert(size() + distance);
                     node_constructor a(data_.allocators_);
 
                     for (; i != j; ++i) {
                         a.construct(*i);
 
-                        key_type const& k = extract_key(a.get()->value_);
+                        key_type const& k = extract_key(a.get()->value());
                         bucket_ptr bucket = get_bucket(k);
                         link_ptr position = find_iterator(bucket, k);
 
@@ -1841,7 +1758,7 @@ namespace boost {
 
                     // reserve has basic exception safety if the hash function
                     // throws, strong otherwise.
-                    if(reserve(size() + 1))
+                    if(reserve_for_insert(size() + 1))
                         bucket = data_.bucket_ptr_from_hash(hash_value);
 
                     // Nothing after this point can throw.
@@ -1880,7 +1797,7 @@ namespace boost {
 
                     // reserve has basic exception safety if the hash function
                     // throws, strong otherwise.
-                    if(reserve(size() + 1))
+                    if(reserve_for_insert(size() + 1))
                         bucket = data_.bucket_ptr_from_hash(hash_value);
 
                     // Nothing after this point can throw.
@@ -1947,7 +1864,7 @@ namespace boost {
 
                     // reserve has basic exception safety if the hash function
                     // throws, strong otherwise.
-                    if(reserve(size() + 1))
+                    if(reserve_for_insert(size() + 1))
                         bucket = data_.bucket_ptr_from_hash(hash_value);
 
                     // Nothing after this point can throw.
@@ -1966,7 +1883,7 @@ namespace boost {
                 a.construct(std::forward<Args>(args)...);
 
                 // No side effects in this initial code
-                key_type const& k = extract_key(a.get()->value_);
+                key_type const& k = extract_key(a.get()->value());
                 size_type hash_value = hash_function()(k);
                 bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value);
                 link_ptr pos = find_iterator(bucket, k);
@@ -1978,7 +1895,7 @@ namespace boost {
                 } else {
                     // reserve has basic exception safety if the hash function
                     // throws, strong otherwise.
-                    if(reserve(size() + 1))
+                    if(reserve_for_insert(size() + 1))
                         bucket = data_.bucket_ptr_from_hash(hash_value);
 
                     // Nothing after this point can throw.
@@ -2047,7 +1964,7 @@ namespace boost {
                         // reserve has basic exception safety if the hash function
                         // throws, strong otherwise.
                         if(size() + 1 >= max_load_) {
-                            reserve(size() + insert_size(i, j));
+                            reserve_for_insert(size() + insert_size(i, j));
                             bucket = data_.bucket_ptr_from_hash(hash_value);
                         }
 

include/boost/unordered/unordered_map.hpp

@@ -0,0 +1,837 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2008 Daniel James.
+// 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)
+
+//  See http://www.boost.org/libs/unordered for documentation
+
+#ifndef BOOST_UNORDERED_UNORDERED_MAP_HPP_INCLUDED
+#define BOOST_UNORDERED_UNORDERED_MAP_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/unordered_map_fwd.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/unordered/detail/hash_table.hpp>
+
+#if !defined(BOOST_HAS_RVALUE_REFS)
+#include <boost/unordered/detail/move.hpp>
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#if BOOST_MSVC >= 1400
+#pragma warning(disable:4396) //the inline specifier cannot be used when a
+                              // friend declaration refers to a specialization
+                              // of a function template
+#endif
+#endif
+
+namespace boost
+{
+    template <class Key, class T, class Hash, class Pred, class Alloc>
+    class unordered_map
+    {
+        typedef boost::unordered_detail::hash_types_unique_keys<
+            std::pair<const Key, T>, Key, Hash, Pred, Alloc
+        > implementation;
+
+        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
+
+    public:
+
+        // types
+
+        typedef Key key_type;
+        typedef std::pair<const Key, T> value_type;
+        typedef T mapped_type;
+        typedef Hash hasher;
+        typedef Pred key_equal;
+
+        typedef Alloc allocator_type;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
+
+        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
+        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
+
+        typedef BOOST_DEDUCED_TYPENAME implementation::iterator iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::local_iterator local_iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
+
+        // construct/destroy/copy
+
+        explicit unordered_map(
+                size_type n = boost::unordered_detail::default_initial_bucket_count,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+            : base(n, hf, eql, a)
+        {
+        }
+
+        explicit unordered_map(allocator_type const& a)
+            : base(boost::unordered_detail::default_initial_bucket_count,
+                hasher(), key_equal(), a)
+        {
+        }
+
+        unordered_map(unordered_map const& other, allocator_type const& a)
+            : base(other.base, a)
+        {
+        }
+
+        template <class InputIterator>
+        unordered_map(InputIterator f, InputIterator l)
+            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
+                hasher(), key_equal(), allocator_type())
+        {
+        }
+
+        template <class InputIterator>
+        unordered_map(InputIterator f, InputIterator l,
+                size_type n,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+            : base(f, l, n, hf, eql, a)
+        {
+        }
+
+#if defined(BOOST_HAS_RVALUE_REFS)
+        unordered_map(unordered_map&& other)
+            : base(other.base, boost::unordered_detail::move_tag())
+        {
+        }
+
+        unordered_map(unordered_map&& other, allocator_type const& a)
+            : base(other.base, a, boost::unordered_detail::move_tag())
+        {
+        }
+
+        unordered_map& operator=(unordered_map&& x)
+        {
+            base.move(x.base);
+            return *this;
+        }
+#else
+        unordered_map(boost::unordered_detail::move_from<unordered_map<Key, T, Hash, Pred, Alloc> > other)
+            : base(other.source.base, boost::unordered_detail::move_tag())
+        {
+        }
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
+        unordered_map& operator=(unordered_map x)
+        {
+            base.move(x.base);
+            return *this;
+        }
+#endif
+#endif
+
+#if !defined(BOOST_NO_INITIALIZER_LISTS)
+        unordered_map(std::initializer_list<value_type> list,
+                size_type n = boost::unordered_detail::default_initial_bucket_count,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+            : base(list.begin(), list.end(), n, hf, eql, a)
+        {
+        }
+
+        unordered_map& operator=(std::initializer_list<value_type> list)
+        {
+            base.data_.clear();
+            base.insert_range(list.begin(), list.end());
+            return *this;
+        }
+#endif
+
+    private:
+
+        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
+            get(const_iterator const& it)
+        {
+            return boost::unordered_detail::iterator_access::get(it);
+        }
+
+    public:
+
+        allocator_type get_allocator() const
+        {
+            return base.get_allocator();
+        }
+
+        // size and capacity
+
+        bool empty() const
+        {
+            return base.empty();
+        }
+
+        size_type size() const
+        {
+            return base.size();
+        }
+
+        size_type max_size() const
+        {
+            return base.max_size();
+        }
+
+        // iterators
+
+        iterator begin()
+        {
+            return iterator(base.data_.begin());
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator(base.data_.begin());
+        }
+
+        iterator end()
+        {
+            return iterator(base.data_.end());
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator(base.data_.end());
+        }
+
+        const_iterator cbegin() const
+        {
+            return const_iterator(base.data_.begin());
+        }
+
+        const_iterator cend() const
+        {
+            return const_iterator(base.data_.end());
+        }
+
+        // modifiers
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+        template <class... Args>
+        std::pair<iterator, bool> emplace(Args&&... args)
+        {
+            return boost::unordered_detail::pair_cast<iterator, bool>(
+                base.insert(std::forward<Args>(args)...));
+        }
+
+        template <class... Args>
+        iterator emplace_hint(const_iterator hint, Args&&... args)
+        {
+            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
+        }
+#endif
+
+        std::pair<iterator, bool> insert(const value_type& obj)
+        {
+            return boost::unordered_detail::pair_cast<iterator, bool>(
+                    base.insert(obj));
+        }
+
+        iterator insert(const_iterator hint, const value_type& obj)
+        {
+            return iterator(base.insert_hint(get(hint), obj));
+        }
+
+        template <class InputIterator>
+            void insert(InputIterator first, InputIterator last)
+        {
+            base.insert_range(first, last);
+        }
+
+        iterator erase(const_iterator position)
+        {
+            return iterator(base.data_.erase(get(position)));
+        }
+
+        size_type erase(const key_type& k)
+        {
+            return base.erase_key(k);
+        }
+
+        iterator erase(const_iterator first, const_iterator last)
+        {
+            return iterator(base.data_.erase_range(get(first), get(last)));
+        }
+
+        void clear()
+        {
+            base.data_.clear();
+        }
+
+        void swap(unordered_map& other)
+        {
+            base.swap(other.base);
+        }
+
+        // observers
+
+        hasher hash_function() const
+        {
+            return base.hash_function();
+        }
+
+        key_equal key_eq() const
+        {
+            return base.key_eq();
+        }
+
+        mapped_type& operator[](const key_type &k)
+        {
+            return base[k].second;
+        }
+
+        mapped_type& at(const key_type& k)
+        {
+            return base.at(k).second;
+        }
+
+        mapped_type const& at(const key_type& k) const
+        {
+            return base.at(k).second;
+        }
+
+        // lookup
+
+        iterator find(const key_type& k)
+        {
+            return iterator(base.find(k));
+        }
+
+        const_iterator find(const key_type& k) const
+        {
+            return const_iterator(base.find(k));
+        }
+
+        size_type count(const key_type& k) const
+        {
+            return base.count(k);
+        }
+
+        std::pair<iterator, iterator>
+            equal_range(const key_type& k)
+        {
+            return boost::unordered_detail::pair_cast<iterator, iterator>(
+                    base.equal_range(k));
+        }
+
+        std::pair<const_iterator, const_iterator>
+            equal_range(const key_type& k) const
+        {
+            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
+                    base.equal_range(k));
+        }
+
+        // bucket interface
+
+        size_type bucket_count() const
+        {
+            return base.bucket_count();
+        }
+
+        size_type max_bucket_count() const
+        {
+            return base.max_bucket_count();
+        }
+
+        size_type bucket_size(size_type n) const
+        {
+            return base.data_.bucket_size(n);
+        }
+
+        size_type bucket(const key_type& k) const
+        {
+            return base.bucket(k);
+        }
+
+        local_iterator begin(size_type n)
+        {
+            return local_iterator(base.data_.begin(n));
+        }
+
+        const_local_iterator begin(size_type n) const
+        {
+            return const_local_iterator(base.data_.begin(n));
+        }
+
+        local_iterator end(size_type n)
+        {
+            return local_iterator(base.data_.end(n));
+        }
+
+        const_local_iterator end(size_type n) const
+        {
+            return const_local_iterator(base.data_.end(n));
+        }
+
+        const_local_iterator cbegin(size_type n) const
+        {
+            return const_local_iterator(base.data_.begin(n));
+        }
+
+        const_local_iterator cend(size_type n) const
+        {
+            return const_local_iterator(base.data_.end(n));
+        }
+
+        // hash policy
+
+        float load_factor() const
+        {
+            return base.load_factor();
+        }
+
+        float max_load_factor() const
+        {
+            return base.max_load_factor();
+        }
+
+        void max_load_factor(float m)
+        {
+            base.max_load_factor(m);
+        }
+
+        void rehash(size_type n)
+        {
+            base.rehash(n);
+        }
+        
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+        friend bool operator==(unordered_map const&, unordered_map const&);
+        friend bool operator!=(unordered_map const&, unordered_map const&);
+#else
+        friend bool operator==<Key, T, Hash, Pred, Alloc>(unordered_map const&, unordered_map const&);
+        friend bool operator!=<Key, T, Hash, Pred, Alloc>(unordered_map const&, unordered_map const&);
+#endif
+    }; // class template unordered_map
+
+    template <class K, class T, class H, class P, class A>
+    inline bool operator==(unordered_map<K, T, H, P, A> const& m1,
+        unordered_map<K, T, H, P, A> const& m2)
+    {
+        return boost::unordered_detail::equals(m1.base, m2.base);
+    }
+
+    template <class K, class T, class H, class P, class A>
+    inline bool operator!=(unordered_map<K, T, H, P, A> const& m1,
+        unordered_map<K, T, H, P, A> const& m2)
+    {
+        return !boost::unordered_detail::equals(m1.base, m2.base);
+    }
+
+    template <class K, class T, class H, class P, class A>
+    inline void swap(unordered_map<K, T, H, P, A> &m1,
+            unordered_map<K, T, H, P, A> &m2)
+    {
+        m1.swap(m2);
+    }
+
+    template <class Key, class T, class Hash, class Pred, class Alloc>
+    class unordered_multimap
+    {
+        typedef boost::unordered_detail::hash_types_equivalent_keys<
+            std::pair<const Key, T>, Key, Hash, Pred, Alloc
+        > implementation;
+
+        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
+
+        public:
+
+        // types
+
+        typedef Key key_type;
+        typedef std::pair<const Key, T> value_type;
+        typedef T mapped_type;
+        typedef Hash hasher;
+        typedef Pred key_equal;
+
+        typedef Alloc allocator_type;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
+
+        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
+        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
+
+        typedef BOOST_DEDUCED_TYPENAME implementation::iterator iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::local_iterator local_iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
+
+        // construct/destroy/copy
+
+        explicit unordered_multimap(
+                size_type n = boost::unordered_detail::default_initial_bucket_count,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+          : base(n, hf, eql, a)
+        {
+        }
+
+        explicit unordered_multimap(allocator_type const& a)
+            : base(boost::unordered_detail::default_initial_bucket_count,
+                hasher(), key_equal(), a)
+        {
+        }
+
+        unordered_multimap(unordered_multimap const& other, allocator_type const& a)
+            : base(other.base, a)
+        {
+        }
+
+        template <class InputIterator>
+        unordered_multimap(InputIterator f, InputIterator l)
+            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
+                hasher(), key_equal(), allocator_type())
+        {
+        }
+
+        template <class InputIterator>
+        unordered_multimap(InputIterator f, InputIterator l,
+                size_type n,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+          : base(f, l, n, hf, eql, a)
+        {
+        }
+
+#if defined(BOOST_HAS_RVALUE_REFS)
+        unordered_multimap(unordered_multimap&& other)
+            : base(other.base, boost::unordered_detail::move_tag())
+        {
+        }
+
+        unordered_multimap(unordered_multimap&& other, allocator_type const& a)
+            : base(other.base, a, boost::unordered_detail::move_tag())
+        {
+        }
+
+        unordered_multimap& operator=(unordered_multimap&& x)
+        {
+            base.move(x.base);
+            return *this;
+        }
+#else
+        unordered_multimap(boost::unordered_detail::move_from<unordered_multimap<Key, T, Hash, Pred, Alloc> > other)
+            : base(other.source.base, boost::unordered_detail::move_tag())
+        {
+        }
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
+        unordered_multimap& operator=(unordered_multimap x)
+        {
+            base.move(x.base);
+            return *this;
+        }
+#endif
+#endif
+
+#if !defined(BOOST_NO_INITIALIZER_LISTS)
+        unordered_multimap(std::initializer_list<value_type> list,
+                size_type n = boost::unordered_detail::default_initial_bucket_count,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+            : base(list.begin(), list.end(), n, hf, eql, a)
+        {
+        }
+
+        unordered_multimap& operator=(std::initializer_list<value_type> list)
+        {
+            base.data_.clear();
+            base.insert_range(list.begin(), list.end());
+            return *this;
+        }
+#endif
+
+
+    private:
+
+        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
+            get(const_iterator const& it)
+        {
+            return boost::unordered_detail::iterator_access::get(it);
+        }
+
+    public:
+
+        allocator_type get_allocator() const
+        {
+            return base.get_allocator();
+        }
+
+        // size and capacity
+
+        bool empty() const
+        {
+            return base.empty();
+        }
+
+        size_type size() const
+        {
+            return base.size();
+        }
+
+        size_type max_size() const
+        {
+            return base.max_size();
+        }
+
+        // iterators
+
+        iterator begin()
+        {
+            return iterator(base.data_.begin());
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator(base.data_.begin());
+        }
+
+        iterator end()
+        {
+            return iterator(base.data_.end());
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator(base.data_.end());
+        }
+
+        const_iterator cbegin() const
+        {
+            return const_iterator(base.data_.begin());
+        }
+
+        const_iterator cend() const
+        {
+            return const_iterator(base.data_.end());
+        }
+
+        // modifiers
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+        template <class... Args>
+        iterator emplace(Args&&... args)
+        {
+            return iterator(base.insert(std::forward<Args>(args)...));
+        }
+
+        template <class... Args>
+        iterator emplace_hint(const_iterator hint, Args&&... args)
+        {
+            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
+        }
+#endif
+
+        iterator insert(const value_type& obj)
+        {
+            return iterator(base.insert(obj));
+        }
+
+        iterator insert(const_iterator hint, const value_type& obj)
+        {
+            return iterator(base.insert_hint(get(hint), obj));
+        }
+
+        template <class InputIterator>
+            void insert(InputIterator first, InputIterator last)
+        {
+            base.insert_range(first, last);
+        }
+
+        iterator erase(const_iterator position)
+        {
+            return iterator(base.data_.erase(get(position)));
+        }
+
+        size_type erase(const key_type& k)
+        {
+            return base.erase_key(k);
+        }
+
+        iterator erase(const_iterator first, const_iterator last)
+        {
+            return iterator(base.data_.erase_range(get(first), get(last)));
+        }
+
+        void clear()
+        {
+            base.data_.clear();
+        }
+
+        void swap(unordered_multimap& other)
+        {
+            base.swap(other.base);
+        }
+
+        // observers
+
+        hasher hash_function() const
+        {
+            return base.hash_function();
+        }
+
+        key_equal key_eq() const
+        {
+            return base.key_eq();
+        }
+
+        // lookup
+
+        iterator find(const key_type& k)
+        {
+            return iterator(base.find(k));
+        }
+
+        const_iterator find(const key_type& k) const
+        {
+            return const_iterator(base.find(k));
+        }
+
+        size_type count(const key_type& k) const
+        {
+            return base.count(k);
+        }
+
+        std::pair<iterator, iterator>
+            equal_range(const key_type& k)
+        {
+            return boost::unordered_detail::pair_cast<iterator, iterator>(
+                    base.equal_range(k));
+        }
+
+        std::pair<const_iterator, const_iterator>
+            equal_range(const key_type& k) const
+        {
+            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
+                    base.equal_range(k));
+        }
+
+        // bucket interface
+
+        size_type bucket_count() const
+        {
+            return base.bucket_count();
+        }
+
+        size_type max_bucket_count() const
+        {
+            return base.max_bucket_count();
+        }
+
+        size_type bucket_size(size_type n) const
+        {
+            return base.data_.bucket_size(n);
+        }
+
+        size_type bucket(const key_type& k) const
+        {
+            return base.bucket(k);
+        }
+
+        local_iterator begin(size_type n)
+        {
+            return local_iterator(base.data_.begin(n));
+        }
+
+        const_local_iterator begin(size_type n) const
+        {
+            return const_local_iterator(base.data_.begin(n));
+        }
+
+        local_iterator end(size_type n)
+        {
+            return local_iterator(base.data_.end(n));
+        }
+
+        const_local_iterator end(size_type n) const
+        {
+            return const_local_iterator(base.data_.end(n));
+        }
+
+        const_local_iterator cbegin(size_type n) const
+        {
+            return const_local_iterator(base.data_.begin(n));
+        }
+
+        const_local_iterator cend(size_type n) const
+        {
+            return const_local_iterator(base.data_.end(n));
+        }
+
+        // hash policy
+
+        float load_factor() const
+        {
+            return base.load_factor();
+        }
+
+        float max_load_factor() const
+        {
+            return base.max_load_factor();
+        }
+
+        void max_load_factor(float m)
+        {
+            base.max_load_factor(m);
+        }
+
+        void rehash(size_type n)
+        {
+            base.rehash(n);
+        }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+        friend bool operator==(unordered_multimap const&, unordered_multimap const&);
+        friend bool operator!=(unordered_multimap const&, unordered_multimap const&);
+#else
+        friend bool operator==<Key, T, Hash, Pred, Alloc>(unordered_multimap const&, unordered_multimap const&);
+        friend bool operator!=<Key, T, Hash, Pred, Alloc>(unordered_multimap const&, unordered_multimap const&);
+#endif
+    }; // class template unordered_multimap
+
+    template <class K, class T, class H, class P, class A>
+    inline bool operator==(unordered_multimap<K, T, H, P, A> const& m1,
+        unordered_multimap<K, T, H, P, A> const& m2)
+    {
+        return boost::unordered_detail::equals(m1.base, m2.base);
+    }
+
+    template <class K, class T, class H, class P, class A>
+    inline bool operator!=(unordered_multimap<K, T, H, P, A> const& m1,
+        unordered_multimap<K, T, H, P, A> const& m2)
+    {
+        return !boost::unordered_detail::equals(m1.base, m2.base);
+    }
+
+    template <class K, class T, class H, class P, class A>
+    inline void swap(unordered_multimap<K, T, H, P, A> &m1,
+            unordered_multimap<K, T, H, P, A> &m2)
+    {
+        m1.swap(m2);
+    }
+
+} // namespace boost
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_UNORDERED_UNORDERED_MAP_HPP_INCLUDED

include/boost/unordered/unordered_map_fwd.hpp

@@ -0,0 +1,53 @@
+
+// Copyright (C) 2008 Daniel James.
+// 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_MAP_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_MAP_FWD_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <memory>
+#include <functional>
+#include <boost/functional/hash_fwd.hpp>
+
+namespace boost
+{
+    template <class Key,
+        class T,
+        class Hash = hash<Key>,
+        class Pred = std::equal_to<Key>,
+        class Alloc = std::allocator<std::pair<const Key, T> > >
+    class unordered_map;
+    template <class K, class T, class H, class P, class A>
+    bool operator==(unordered_map<K, T, H, P, A> const&,
+        unordered_map<K, T, H, P, A> const&);
+    template <class K, class T, class H, class P, class A>
+    bool operator!=(unordered_map<K, T, H, P, A> const&,
+        unordered_map<K, T, H, P, A> const&);
+    template <class K, class T, class H, class P, class A>
+    void swap(unordered_map<K, T, H, P, A>&,
+            unordered_map<K, T, H, P, A>&);
+
+    template <class Key,
+        class T,
+        class Hash = hash<Key>,
+        class Pred = std::equal_to<Key>,
+        class Alloc = std::allocator<std::pair<const Key, T> > >
+    class unordered_multimap;
+    template <class K, class T, class H, class P, class A>
+    bool operator==(unordered_multimap<K, T, H, P, A> const&,
+        unordered_multimap<K, T, H, P, A> const&);
+    template <class K, class T, class H, class P, class A>
+    bool operator!=(unordered_multimap<K, T, H, P, A> const&,
+        unordered_multimap<K, T, H, P, A> const&);
+    template <class K, class T, class H, class P, class A>
+    void swap(unordered_multimap<K, T, H, P, A>&,
+            unordered_multimap<K, T, H, P, A>&);
+}
+
+#endif

include/boost/unordered/unordered_set.hpp

@@ -0,0 +1,794 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2008 Daniel James.
+// 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)
+
+//  See http://www.boost.org/libs/unordered for documentation
+
+#ifndef BOOST_UNORDERED_UNORDERED_SET_HPP_INCLUDED
+#define BOOST_UNORDERED_UNORDERED_SET_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/unordered_set_fwd.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/unordered/detail/hash_table.hpp>
+
+#if !defined(BOOST_HAS_RVALUE_REFS)
+#include <boost/unordered/detail/move.hpp>
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#if BOOST_MSVC >= 1400
+#pragma warning(disable:4396) //the inline specifier cannot be used when a
+                              // friend declaration refers to a specialization
+                              // of a function template
+#endif
+#endif
+
+namespace boost
+{
+    template <class Value, class Hash, class Pred, class Alloc>
+    class unordered_set
+    {
+        typedef boost::unordered_detail::hash_types_unique_keys<
+            Value, Value, Hash, Pred, Alloc
+        > implementation;
+
+        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
+
+    public:
+
+        // types
+
+        typedef Value key_type;
+        typedef Value value_type;
+        typedef Hash hasher;
+        typedef Pred key_equal;
+
+        typedef Alloc allocator_type;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
+
+        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
+        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
+
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator local_iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
+
+        // construct/destroy/copy
+
+        explicit unordered_set(
+                size_type n = boost::unordered_detail::default_initial_bucket_count,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+            : base(n, hf, eql, a)
+        {
+        }
+
+        explicit unordered_set(allocator_type const& a)
+            : base(boost::unordered_detail::default_initial_bucket_count,
+                hasher(), key_equal(), a)
+        {
+        }
+
+        unordered_set(unordered_set const& other, allocator_type const& a)
+            : base(other.base, a)
+        {
+        }
+
+        template <class InputIterator>
+        unordered_set(InputIterator f, InputIterator l)
+            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
+                hasher(), key_equal(), allocator_type())
+        {
+        }
+
+        template <class InputIterator>
+        unordered_set(InputIterator f, InputIterator l, size_type n,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+            : base(f, l, n, hf, eql, a)
+        {
+        }
+
+#if defined(BOOST_HAS_RVALUE_REFS)
+        unordered_set(unordered_set&& other)
+            : base(other.base, boost::unordered_detail::move_tag())
+        {
+        }
+
+        unordered_set(unordered_set&& other, allocator_type const& a)
+            : base(other.base, a, boost::unordered_detail::move_tag())
+        {
+        }
+
+        unordered_set& operator=(unordered_set&& x)
+        {
+            base.move(x.base);
+            return *this;
+        }
+#else
+        unordered_set(boost::unordered_detail::move_from<unordered_set<Value, Hash, Pred, Alloc> > other)
+            : base(other.source.base, boost::unordered_detail::move_tag())
+        {
+        }
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
+        unordered_set& operator=(unordered_set x)
+        {
+            base.move(x.base);
+            return *this;
+        }
+#endif
+#endif
+
+#if !defined(BOOST_NO_INITIALIZER_LISTS)
+        unordered_set(std::initializer_list<value_type> list,
+                size_type n = boost::unordered_detail::default_initial_bucket_count,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+            : base(list.begin(), list.end(), n, hf, eql, a)
+        {
+        }
+
+        unordered_set& operator=(std::initializer_list<value_type> list)
+        {
+            base.data_.clear();
+            base.insert_range(list.begin(), list.end());
+            return *this;
+        }
+#endif
+
+    private:
+
+        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
+            get(const_iterator const& it)
+        {
+            return boost::unordered_detail::iterator_access::get(it);
+        }
+
+    public:
+
+        allocator_type get_allocator() const
+        {
+            return base.get_allocator();
+        }
+
+        // size and capacity
+
+        bool empty() const
+        {
+            return base.empty();
+        }
+
+        size_type size() const
+        {
+            return base.size();
+        }
+
+        size_type max_size() const
+        {
+            return base.max_size();
+        }
+
+        // iterators
+
+        iterator begin()
+        {
+            return iterator(base.data_.begin());
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator(base.data_.begin());
+        }
+
+        iterator end()
+        {
+            return iterator(base.data_.end());
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator(base.data_.end());
+        }
+
+        const_iterator cbegin() const
+        {
+            return const_iterator(base.data_.begin());
+        }
+
+        const_iterator cend() const
+        {
+            return const_iterator(base.data_.end());
+        }
+
+        // modifiers
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+        template <class... Args>
+        std::pair<iterator, bool> emplace(Args&&... args)
+        {
+            return boost::unordered_detail::pair_cast<iterator, bool>(
+                base.insert(std::forward<Args>(args)...));
+        }
+
+        template <class... Args>
+        iterator emplace_hint(const_iterator hint, Args&&... args)
+        {
+            return iterator(
+                base.insert_hint(get(hint), std::forward<Args>(args)...));
+        }
+#endif
+
+        std::pair<iterator, bool> insert(const value_type& obj)
+        {
+            return boost::unordered_detail::pair_cast<iterator, bool>(
+                    base.insert(obj));
+        }
+
+        iterator insert(const_iterator hint, const value_type& obj)
+        {
+            return iterator(base.insert_hint(get(hint), obj));
+        }
+
+        template <class InputIterator>
+            void insert(InputIterator first, InputIterator last)
+        {
+            base.insert_range(first, last);
+        }
+
+        iterator erase(const_iterator position)
+        {
+            return iterator(base.data_.erase(get(position)));
+        }
+
+        size_type erase(const key_type& k)
+        {
+            return base.erase_key(k);
+        }
+
+        iterator erase(const_iterator first, const_iterator last)
+        {
+            return iterator(base.data_.erase_range(get(first), get(last)));
+        }
+
+        void clear()
+        {
+            base.data_.clear();
+        }
+
+        void swap(unordered_set& other)
+        {
+            base.swap(other.base);
+        }
+
+        // observers
+
+        hasher hash_function() const
+        {
+            return base.hash_function();
+        }
+
+        key_equal key_eq() const
+        {
+            return base.key_eq();
+        }
+
+        // lookup
+
+        const_iterator find(const key_type& k) const
+        {
+            return const_iterator(base.find(k));
+        }
+
+        size_type count(const key_type& k) const
+        {
+            return base.count(k);
+        }
+
+        std::pair<const_iterator, const_iterator>
+            equal_range(const key_type& k) const
+        {
+            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
+                    base.equal_range(k));
+        }
+
+        // bucket interface
+
+        size_type bucket_count() const
+        {
+            return base.bucket_count();
+        }
+
+        size_type max_bucket_count() const
+        {
+            return base.max_bucket_count();
+        }
+
+        size_type bucket_size(size_type n) const
+        {
+            return base.data_.bucket_size(n);
+        }
+
+        size_type bucket(const key_type& k) const
+        {
+            return base.bucket(k);
+        }
+
+        local_iterator begin(size_type n)
+        {
+            return local_iterator(base.data_.begin(n));
+        }
+
+        const_local_iterator begin(size_type n) const
+        {
+            return const_local_iterator(base.data_.begin(n));
+        }
+
+        local_iterator end(size_type n)
+        {
+            return local_iterator(base.data_.end(n));
+        }
+
+        const_local_iterator end(size_type n) const
+        {
+            return const_local_iterator(base.data_.end(n));
+        }
+
+        const_local_iterator cbegin(size_type n) const
+        {
+            return const_local_iterator(base.data_.begin(n));
+        }
+
+        const_local_iterator cend(size_type n) const
+        {
+            return const_local_iterator(base.data_.end(n));
+        }
+
+        // hash policy
+
+        float load_factor() const
+        {
+            return base.load_factor();
+        }
+
+        float max_load_factor() const
+        {
+            return base.max_load_factor();
+        }
+
+        void max_load_factor(float m)
+        {
+            base.max_load_factor(m);
+        }
+
+        void rehash(size_type n)
+        {
+            base.rehash(n);
+        }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+        friend bool operator==(unordered_set const&, unordered_set const&);
+        friend bool operator!=(unordered_set const&, unordered_set const&);
+#else
+        friend bool operator==<Value, Hash, Pred, Alloc>(unordered_set const&, unordered_set const&);
+        friend bool operator!=<Value, Hash, Pred, Alloc>(unordered_set const&, unordered_set const&);
+#endif
+    }; // class template unordered_set
+
+    template <class T, class H, class P, class A>
+    inline bool operator==(unordered_set<T, H, P, A> const& m1,
+        unordered_set<T, H, P, A> const& m2)
+    {
+        return boost::unordered_detail::equals(m1.base, m2.base);
+    }
+
+    template <class T, class H, class P, class A>
+    inline bool operator!=(unordered_set<T, H, P, A> const& m1,
+        unordered_set<T, H, P, A> const& m2)
+    {
+        return !boost::unordered_detail::equals(m1.base, m2.base);
+    }
+
+    template <class T, class H, class P, class A>
+    inline void swap(unordered_set<T, H, P, A> &m1,
+            unordered_set<T, H, P, A> &m2)
+    {
+        m1.swap(m2);
+    }
+
+    template <class Value, class Hash, class Pred, class Alloc>
+    class unordered_multiset
+    {
+        typedef boost::unordered_detail::hash_types_equivalent_keys<
+            Value, Value, Hash, Pred, Alloc
+        > implementation;
+
+        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
+
+    public:
+
+        //types
+
+        typedef Value key_type;
+        typedef Value value_type;
+        typedef Hash hasher;
+        typedef Pred key_equal;
+
+        typedef Alloc allocator_type;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
+        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
+
+        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
+        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
+
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator local_iterator;
+        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
+
+        // construct/destroy/copy
+
+        explicit unordered_multiset(
+                size_type n = boost::unordered_detail::default_initial_bucket_count,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+          : base(n, hf, eql, a)
+        {
+        }
+
+        explicit unordered_multiset(allocator_type const& a)
+            : base(boost::unordered_detail::default_initial_bucket_count,
+                hasher(), key_equal(), a)
+        {
+        }
+
+        unordered_multiset(unordered_multiset const& other, allocator_type const& a)
+            : base(other.base, a)
+        {
+        }
+
+        template <class InputIterator>
+        unordered_multiset(InputIterator f, InputIterator l)
+            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
+                hasher(), key_equal(), allocator_type())
+        {
+        }
+
+        template <class InputIterator>
+        unordered_multiset(InputIterator f, InputIterator l, size_type n,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+          : base(f, l, n, hf, eql, a)
+        {
+        }
+
+#if defined(BOOST_HAS_RVALUE_REFS)
+        unordered_multiset(unordered_multiset&& other)
+            : base(other.base, boost::unordered_detail::move_tag())
+        {
+        }
+
+        unordered_multiset(unordered_multiset&& other, allocator_type const& a)
+            : base(other.base, a, boost::unordered_detail::move_tag())
+        {
+        }
+
+        unordered_multiset& operator=(unordered_multiset&& x)
+        {
+            base.move(x.base);
+            return *this;
+        }
+#else
+        unordered_multiset(boost::unordered_detail::move_from<unordered_multiset<Value, Hash, Pred, Alloc> > other)
+            : base(other.source.base, boost::unordered_detail::move_tag())
+        {
+        }
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
+        unordered_multiset& operator=(unordered_multiset x)
+        {
+            base.move(x.base);
+            return *this;
+        }
+#endif
+#endif
+
+#if !defined(BOOST_NO_INITIALIZER_LISTS)
+        unordered_multiset(std::initializer_list<value_type> list,
+                size_type n = boost::unordered_detail::default_initial_bucket_count,
+                const hasher &hf = hasher(),
+                const key_equal &eql = key_equal(),
+                const allocator_type &a = allocator_type())
+            : base(list.begin(), list.end(), n, hf, eql, a)
+        {
+        }
+
+        unordered_multiset& operator=(std::initializer_list<value_type> list)
+        {
+            base.data_.clear();
+            base.insert_range(list.begin(), list.end());
+            return *this;
+        }
+#endif
+
+    private:
+
+        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
+            get(const_iterator const& it)
+        {
+            return boost::unordered_detail::iterator_access::get(it);
+        }
+
+    public:
+
+        allocator_type get_allocator() const
+        {
+            return base.get_allocator();
+        }
+
+        // size and capacity
+
+        bool empty() const
+        {
+            return base.empty();
+        }
+
+        size_type size() const
+        {
+            return base.size();
+        }
+
+        size_type max_size() const
+        {
+            return base.max_size();
+        }
+
+        // iterators
+
+        iterator begin()
+        {
+            return iterator(base.data_.begin());
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator(base.data_.begin());
+        }
+
+        iterator end()
+        {
+            return iterator(base.data_.end());
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator(base.data_.end());
+        }
+
+        const_iterator cbegin() const
+        {
+            return const_iterator(base.data_.begin());
+        }
+
+        const_iterator cend() const
+        {
+            return const_iterator(base.data_.end());
+        }
+
+        // modifiers
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+        template <class... Args>
+        iterator emplace(Args&&... args)
+        {
+            return iterator(base.insert(std::forward<Args>(args)...));
+        }
+
+        template <class... Args>
+        iterator emplace_hint(const_iterator hint, Args&&... args)
+        {
+            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
+        }
+#endif
+
+        iterator insert(const value_type& obj)
+        {
+            return iterator(base.insert(obj));
+        }
+
+        iterator insert(const_iterator hint, const value_type& obj)
+        {
+            return iterator(base.insert_hint(get(hint), obj));
+        }
+
+        template <class InputIterator>
+            void insert(InputIterator first, InputIterator last)
+        {
+            base.insert_range(first, last);
+        }
+
+        iterator erase(const_iterator position)
+        {
+            return iterator(base.data_.erase(get(position)));
+        }
+
+        size_type erase(const key_type& k)
+        {
+            return base.erase_key(k);
+        }
+
+        iterator erase(const_iterator first, const_iterator last)
+        {
+            return iterator(base.data_.erase_range(get(first), get(last)));
+        }
+
+        void clear()
+        {
+            base.data_.clear();
+        }
+
+        void swap(unordered_multiset& other)
+        {
+            base.swap(other.base);
+        }
+
+        // observers
+
+        hasher hash_function() const
+        {
+            return base.hash_function();
+        }
+
+        key_equal key_eq() const
+        {
+            return base.key_eq();
+        }
+
+        // lookup
+
+        const_iterator find(const key_type& k) const
+        {
+            return const_iterator(base.find(k));
+        }
+
+        size_type count(const key_type& k) const
+        {
+            return base.count(k);
+        }
+
+        std::pair<const_iterator, const_iterator>
+            equal_range(const key_type& k) const
+        {
+            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
+                    base.equal_range(k));
+        }
+
+        // bucket interface
+
+        size_type bucket_count() const
+        {
+            return base.bucket_count();
+        }
+
+        size_type max_bucket_count() const
+        {
+            return base.max_bucket_count();
+        }
+
+        size_type bucket_size(size_type n) const
+        {
+            return base.data_.bucket_size(n);
+        }
+
+        size_type bucket(const key_type& k) const
+        {
+            return base.bucket(k);
+        }
+
+        local_iterator begin(size_type n)
+        {
+            return local_iterator(base.data_.begin(n));
+        }
+
+        const_local_iterator begin(size_type n) const
+        {
+            return const_local_iterator(base.data_.begin(n));
+        }
+
+        local_iterator end(size_type n)
+        {
+            return local_iterator(base.data_.end(n));
+        }
+
+        const_local_iterator end(size_type n) const
+        {
+            return const_local_iterator(base.data_.end(n));
+        }
+
+        const_local_iterator cbegin(size_type n) const
+        {
+            return const_local_iterator(base.data_.begin(n));
+        }
+
+        const_local_iterator cend(size_type n) const
+        {
+            return const_local_iterator(base.data_.end(n));
+        }
+
+        // hash policy
+
+        float load_factor() const
+        {
+            return base.load_factor();
+        }
+
+        float max_load_factor() const
+        {
+            return base.max_load_factor();
+        }
+
+        void max_load_factor(float m)
+        {
+            base.max_load_factor(m);
+        }
+
+        void rehash(size_type n)
+        {
+            base.rehash(n);
+        }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+        friend bool operator==(unordered_multiset const&, unordered_multiset const&);
+        friend bool operator!=(unordered_multiset const&, unordered_multiset const&);
+#else
+        friend bool operator==<Value, Hash, Pred, Alloc>(unordered_multiset const&, unordered_multiset const&);
+        friend bool operator!=<Value, Hash, Pred, Alloc>(unordered_multiset const&, unordered_multiset const&);
+#endif
+    }; // class template unordered_multiset
+
+    template <class T, class H, class P, class A>
+    inline bool operator==(unordered_multiset<T, H, P, A> const& m1,
+        unordered_multiset<T, H, P, A> const& m2)
+    {
+        return boost::unordered_detail::equals(m1.base, m2.base);
+    }
+
+    template <class T, class H, class P, class A>
+    inline bool operator!=(unordered_multiset<T, H, P, A> const& m1,
+        unordered_multiset<T, H, P, A> const& m2)
+    {
+        return !boost::unordered_detail::equals(m1.base, m2.base);
+    }
+
+    template <class T, class H, class P, class A>
+    inline void swap(unordered_multiset<T, H, P, A> &m1,
+            unordered_multiset<T, H, P, A> &m2)
+    {
+        m1.swap(m2);
+    }
+
+} // namespace boost
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_UNORDERED_UNORDERED_SET_HPP_INCLUDED

include/boost/unordered/unordered_set_fwd.hpp

@@ -0,0 +1,51 @@
+
+// Copyright (C) 2008 Daniel James.
+// 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_SET_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_SET_FWD_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <memory>
+#include <functional>
+#include <boost/functional/hash_fwd.hpp>
+
+namespace boost
+{
+    template <class Value,
+        class Hash = hash<Value>,
+        class Pred = std::equal_to<Value>,
+        class Alloc = std::allocator<Value> >
+    class unordered_set;
+    template <class T, class H, class P, class A>
+    bool operator==(unordered_set<T, H, P, A> const&,
+        unordered_set<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    bool operator!=(unordered_set<T, H, P, A> const&,
+        unordered_set<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    void swap(unordered_set<T, H, P, A> &m1,
+            unordered_set<T, H, P, A> &m2);
+
+    template <class Value,
+        class Hash = hash<Value>,
+        class Pred = std::equal_to<Value>,
+        class Alloc = std::allocator<Value> >
+    class unordered_multiset;
+    template <class T, class H, class P, class A>
+    bool operator==(unordered_multiset<T, H, P, A> const&,
+        unordered_multiset<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    bool operator!=(unordered_multiset<T, H, P, A> const&,
+        unordered_multiset<T, H, P, A> const&);
+    template <class T, class H, class P, class A>
+    void swap(unordered_multiset<T, H, P, A> &m1,
+            unordered_multiset<T, H, P, A> &m2);
+}
+
+#endif

include/boost/unordered_map.hpp

@@ -13,812 +13,6 @@
 # pragma once
 #endif
 
-#include <boost/config.hpp>
-
-#include <functional>
-#include <memory>
-
-#include <boost/functional/hash.hpp>
-#include <boost/unordered/detail/hash_table.hpp>
-
-#if !defined(BOOST_HAS_RVALUE_REFS)
-#include <boost/unordered/detail/move.hpp>
-#endif
-
-namespace boost
-{
-    template <class Key,
-        class T,
-        class Hash = hash<Key>,
-        class Pred = std::equal_to<Key>,
-        class Alloc = std::allocator<std::pair<const Key, T> > >
-    class unordered_map;
-    template <class K, class T, class H, class P, class A>
-    bool operator==(unordered_map<K, T, H, P, A> const&,
-        unordered_map<K, T, H, P, A> const&);
-    template <class K, class T, class H, class P, class A>
-    bool operator!=(unordered_map<K, T, H, P, A> const&,
-        unordered_map<K, T, H, P, A> const&);
-    template <class K, class T, class H, class P, class A>
-    void swap(unordered_map<K, T, H, P, A>&,
-            unordered_map<K, T, H, P, A>&);
-
-    template <class Key,
-        class T,
-        class Hash = hash<Key>,
-        class Pred = std::equal_to<Key>,
-        class Alloc = std::allocator<std::pair<const Key, T> > >
-    class unordered_multimap;
-    template <class K, class T, class H, class P, class A>
-    bool operator==(unordered_multimap<K, T, H, P, A> const&,
-        unordered_multimap<K, T, H, P, A> const&);
-    template <class K, class T, class H, class P, class A>
-    bool operator!=(unordered_multimap<K, T, H, P, A> const&,
-        unordered_multimap<K, T, H, P, A> const&);
-    template <class K, class T, class H, class P, class A>
-    void swap(unordered_multimap<K, T, H, P, A>&,
-            unordered_multimap<K, T, H, P, A>&);
-
-    template <class Key, class T, class Hash, class Pred, class Alloc>
-    class unordered_map
-    {
-        typedef boost::unordered_detail::hash_types_unique_keys<
-            std::pair<const Key, T>, Key, Hash, Pred, Alloc
-        > implementation;
-
-        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
-
-    public:
-
-        // types
-
-        typedef Key key_type;
-        typedef std::pair<const Key, T> value_type;
-        typedef T mapped_type;
-        typedef Hash hasher;
-        typedef Pred key_equal;
-
-        typedef Alloc allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
-        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::iterator iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::local_iterator local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
-
-        // construct/destroy/copy
-
-        explicit unordered_map(
-                size_type n = boost::unordered_detail::default_initial_bucket_count,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-            : base(n, hf, eql, a)
-        {
-        }
-
-        explicit unordered_map(allocator_type const& a)
-            : base(boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), a)
-        {
-        }
-
-        unordered_map(unordered_map const& other, allocator_type const& a)
-            : base(other.base, a)
-        {
-        }
-
-        template <class InputIterator>
-        unordered_map(InputIterator f, InputIterator l)
-            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_map(InputIterator f, InputIterator l,
-                size_type n,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-            : base(f, l, n, hf, eql, a)
-        {
-        }
-
-#if defined(BOOST_HAS_RVALUE_REFS)
-        unordered_map(unordered_map&& other)
-            : base(other.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_map(unordered_map&& other, allocator_type const& a)
-            : base(other.base, a, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_map& operator=(unordered_map&& x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#else
-        unordered_map(boost::unordered_detail::move_from<unordered_map<Key, T, Hash, Pred, Alloc> > other)
-            : base(other.source.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
-        unordered_map& operator=(unordered_map x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#endif
-#endif
-
-    private:
-
-        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
-            get(const_iterator const& it)
-        {
-            return boost::unordered_detail::iterator_access::get(it);
-        }
-
-    public:
-
-        allocator_type get_allocator() const
-        {
-            return base.get_allocator();
-        }
-
-        // size and capacity
-
-        bool empty() const
-        {
-            return base.empty();
-        }
-
-        size_type size() const
-        {
-            return base.size();
-        }
-
-        size_type max_size() const
-        {
-            return base.max_size();
-        }
-
-        // iterators
-
-        iterator begin()
-        {
-            return iterator(base.data_.begin());
-        }
-
-        const_iterator begin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        iterator end()
-        {
-            return iterator(base.data_.end());
-        }
-
-        const_iterator end() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        const_iterator cbegin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        const_iterator cend() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        // modifiers
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template <class... Args>
-        std::pair<iterator, bool> emplace(Args&&... args)
-        {
-            return boost::unordered_detail::pair_cast<iterator, bool>(
-                base.insert(std::forward<Args>(args)...));
-        }
-
-        template <class... Args>
-        iterator emplace(const_iterator hint, Args&&... args)
-        {
-            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
-        }
-#endif
-
-        std::pair<iterator, bool> insert(const value_type& obj)
-        {
-            return boost::unordered_detail::pair_cast<iterator, bool>(
-                    base.insert(obj));
-        }
-
-        iterator insert(const_iterator hint, const value_type& obj)
-        {
-            return iterator(base.insert_hint(get(hint), obj));
-        }
-
-        template <class InputIterator>
-            void insert(InputIterator first, InputIterator last)
-        {
-            base.insert_range(first, last);
-        }
-
-        iterator erase(const_iterator position)
-        {
-            return iterator(base.data_.erase(get(position)));
-        }
-
-        size_type erase(const key_type& k)
-        {
-            return base.erase_key(k);
-        }
-
-        iterator erase(const_iterator first, const_iterator last)
-        {
-            return iterator(base.data_.erase_range(get(first), get(last)));
-        }
-
-        void clear()
-        {
-            base.data_.clear();
-        }
-
-        void swap(unordered_map& other)
-        {
-            base.swap(other.base);
-        }
-
-        // observers
-
-        hasher hash_function() const
-        {
-            return base.hash_function();
-        }
-
-        key_equal key_eq() const
-        {
-            return base.key_eq();
-        }
-
-        mapped_type& operator[](const key_type &k)
-        {
-            return base[k].second;
-        }
-
-        mapped_type& at(const key_type& k)
-        {
-            return base.at(k).second;
-        }
-
-        mapped_type const& at(const key_type& k) const
-        {
-            return base.at(k).second;
-        }
-
-        // lookup
-
-        iterator find(const key_type& k)
-        {
-            return iterator(base.find(k));
-        }
-
-        const_iterator find(const key_type& k) const
-        {
-            return const_iterator(base.find(k));
-        }
-
-        size_type count(const key_type& k) const
-        {
-            return base.count(k);
-        }
-
-        std::pair<iterator, iterator>
-            equal_range(const key_type& k)
-        {
-            return boost::unordered_detail::pair_cast<iterator, iterator>(
-                    base.equal_range(k));
-        }
-
-        std::pair<const_iterator, const_iterator>
-            equal_range(const key_type& k) const
-        {
-            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
-                    base.equal_range(k));
-        }
-
-        // bucket interface
-
-        size_type bucket_count() const
-        {
-            return base.bucket_count();
-        }
-
-        size_type max_bucket_count() const
-        {
-            return base.max_bucket_count();
-        }
-
-        size_type bucket_size(size_type n) const
-        {
-            return base.data_.bucket_size(n);
-        }
-
-        size_type bucket(const key_type& k) const
-        {
-            return base.bucket(k);
-        }
-
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        local_iterator end(size_type n)
-        {
-            return local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator end(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator cend(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        // hash policy
-
-        float load_factor() const
-        {
-            return base.load_factor();
-        }
-
-        float max_load_factor() const
-        {
-            return base.max_load_factor();
-        }
-
-        void max_load_factor(float m)
-        {
-            base.max_load_factor(m);
-        }
-
-        void rehash(size_type n)
-        {
-            base.rehash(n);
-        }
-        
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        friend bool operator==(unordered_map const&, unordered_map const&);
-        friend bool operator!=(unordered_map const&, unordered_map const&);
-#else
-        friend bool operator==<>(unordered_map const&, unordered_map const&);
-        friend bool operator!=<>(unordered_map const&, unordered_map const&);
-#endif
-    }; // class template unordered_map
-
-    template <class K, class T, class H, class P, class A>
-    inline bool operator==(unordered_map<K, T, H, P, A> const& m1,
-        unordered_map<K, T, H, P, A> const& m2)
-    {
-        return boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class K, class T, class H, class P, class A>
-    inline bool operator!=(unordered_map<K, T, H, P, A> const& m1,
-        unordered_map<K, T, H, P, A> const& m2)
-    {
-        return !boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class K, class T, class H, class P, class A>
-    inline void swap(unordered_map<K, T, H, P, A> &m1,
-            unordered_map<K, T, H, P, A> &m2)
-    {
-        m1.swap(m2);
-    }
-
-    template <class Key, class T, class Hash, class Pred, class Alloc>
-    class unordered_multimap
-    {
-        typedef boost::unordered_detail::hash_types_equivalent_keys<
-            std::pair<const Key, T>, Key, Hash, Pred, Alloc
-        > implementation;
-
-        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
-
-        public:
-
-        // types
-
-        typedef Key key_type;
-        typedef std::pair<const Key, T> value_type;
-        typedef T mapped_type;
-        typedef Hash hasher;
-        typedef Pred key_equal;
-
-        typedef Alloc allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
-        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::iterator iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::local_iterator local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
-
-        // construct/destroy/copy
-
-        explicit unordered_multimap(
-                size_type n = boost::unordered_detail::default_initial_bucket_count,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-          : base(n, hf, eql, a)
-        {
-        }
-
-        explicit unordered_multimap(allocator_type const& a)
-            : base(boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), a)
-        {
-        }
-
-        unordered_multimap(unordered_multimap const& other, allocator_type const& a)
-            : base(other.base, a)
-        {
-        }
-
-        template <class InputIterator>
-        unordered_multimap(InputIterator f, InputIterator l)
-            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_multimap(InputIterator f, InputIterator l,
-                size_type n,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-          : base(f, l, n, hf, eql, a)
-        {
-        }
-
-#if defined(BOOST_HAS_RVALUE_REFS)
-        unordered_multimap(unordered_multimap&& other)
-            : base(other.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_multimap(unordered_multimap&& other, allocator_type const& a)
-            : base(other.base, a, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_multimap& operator=(unordered_multimap&& x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#else
-        unordered_multimap(boost::unordered_detail::move_from<unordered_multimap<Key, T, Hash, Pred, Alloc> > other)
-            : base(other.source.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
-        unordered_multimap& operator=(unordered_multimap x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#endif
-#endif
-
-
-    private:
-
-        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
-            get(const_iterator const& it)
-        {
-            return boost::unordered_detail::iterator_access::get(it);
-        }
-
-    public:
-
-        allocator_type get_allocator() const
-        {
-            return base.get_allocator();
-        }
-
-        // size and capacity
-
-        bool empty() const
-        {
-            return base.empty();
-        }
-
-        size_type size() const
-        {
-            return base.size();
-        }
-
-        size_type max_size() const
-        {
-            return base.max_size();
-        }
-
-        // iterators
-
-        iterator begin()
-        {
-            return iterator(base.data_.begin());
-        }
-
-        const_iterator begin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        iterator end()
-        {
-            return iterator(base.data_.end());
-        }
-
-        const_iterator end() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        const_iterator cbegin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        const_iterator cend() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        // modifiers
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template <class... Args>
-        iterator emplace(Args&&... args)
-        {
-            return iterator(base.insert(std::forward<Args>(args)...));
-        }
-
-        template <class... Args>
-        iterator emplace(const_iterator hint, Args&&... args)
-        {
-            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
-        }
-#endif
-
-        iterator insert(const value_type& obj)
-        {
-            return iterator(base.insert(obj));
-        }
-
-        iterator insert(const_iterator hint, const value_type& obj)
-        {
-            return iterator(base.insert_hint(get(hint), obj));
-        }
-
-        template <class InputIterator>
-            void insert(InputIterator first, InputIterator last)
-        {
-            base.insert_range(first, last);
-        }
-
-        iterator erase(const_iterator position)
-        {
-            return iterator(base.data_.erase(get(position)));
-        }
-
-        size_type erase(const key_type& k)
-        {
-            return base.erase_key(k);
-        }
-
-        iterator erase(const_iterator first, const_iterator last)
-        {
-            return iterator(base.data_.erase_range(get(first), get(last)));
-        }
-
-        void clear()
-        {
-            base.data_.clear();
-        }
-
-        void swap(unordered_multimap& other)
-        {
-            base.swap(other.base);
-        }
-
-        // observers
-
-        hasher hash_function() const
-        {
-            return base.hash_function();
-        }
-
-        key_equal key_eq() const
-        {
-            return base.key_eq();
-        }
-
-        // lookup
-
-        iterator find(const key_type& k)
-        {
-            return iterator(base.find(k));
-        }
-
-        const_iterator find(const key_type& k) const
-        {
-            return const_iterator(base.find(k));
-        }
-
-        size_type count(const key_type& k) const
-        {
-            return base.count(k);
-        }
-
-        std::pair<iterator, iterator>
-            equal_range(const key_type& k)
-        {
-            return boost::unordered_detail::pair_cast<iterator, iterator>(
-                    base.equal_range(k));
-        }
-
-        std::pair<const_iterator, const_iterator>
-            equal_range(const key_type& k) const
-        {
-            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
-                    base.equal_range(k));
-        }
-
-        // bucket interface
-
-        size_type bucket_count() const
-        {
-            return base.bucket_count();
-        }
-
-        size_type max_bucket_count() const
-        {
-            return base.max_bucket_count();
-        }
-
-        size_type bucket_size(size_type n) const
-        {
-            return base.data_.bucket_size(n);
-        }
-
-        size_type bucket(const key_type& k) const
-        {
-            return base.bucket(k);
-        }
-
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        local_iterator end(size_type n)
-        {
-            return local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator end(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator cend(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        // hash policy
-
-        float load_factor() const
-        {
-            return base.load_factor();
-        }
-
-        float max_load_factor() const
-        {
-            return base.max_load_factor();
-        }
-
-        void max_load_factor(float m)
-        {
-            base.max_load_factor(m);
-        }
-
-        void rehash(size_type n)
-        {
-            base.rehash(n);
-        }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        friend bool operator==(unordered_multimap const&, unordered_multimap const&);
-        friend bool operator!=(unordered_multimap const&, unordered_multimap const&);
-#else
-        friend bool operator==<>(unordered_multimap const&, unordered_multimap const&);
-        friend bool operator!=<>(unordered_multimap const&, unordered_multimap const&);
-#endif
-    }; // class template unordered_multimap
-
-    template <class K, class T, class H, class P, class A>
-    inline bool operator==(unordered_multimap<K, T, H, P, A> const& m1,
-        unordered_multimap<K, T, H, P, A> const& m2)
-    {
-        return boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class K, class T, class H, class P, class A>
-    inline bool operator!=(unordered_multimap<K, T, H, P, A> const& m1,
-        unordered_multimap<K, T, H, P, A> const& m2)
-    {
-        return !boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class K, class T, class H, class P, class A>
-    inline void swap(unordered_multimap<K, T, H, P, A> &m1,
-            unordered_multimap<K, T, H, P, A> &m2)
-    {
-        m1.swap(m2);
-    }
-
-} // namespace boost
+#include <boost/unordered/unordered_map.hpp>
 
 #endif // BOOST_UNORDERED_MAP_HPP_INCLUDED

include/boost/unordered_set.hpp

@@ -13,767 +13,6 @@
 # pragma once
 #endif
 
-#include <boost/config.hpp>
-
-#include <functional>
-#include <memory>
-
-#include <boost/functional/hash.hpp>
-#include <boost/unordered/detail/hash_table.hpp>
-
-#if !defined(BOOST_HAS_RVALUE_REFS)
-#include <boost/unordered/detail/move.hpp>
-#endif
-
-namespace boost
-{
-    template <class Value,
-        class Hash = hash<Value>,
-        class Pred = std::equal_to<Value>,
-        class Alloc = std::allocator<Value> >
-    class unordered_set;
-    template <class T, class H, class P, class A>
-    bool operator==(unordered_set<T, H, P, A> const&,
-        unordered_set<T, H, P, A> const&);
-    template <class T, class H, class P, class A>
-    bool operator!=(unordered_set<T, H, P, A> const&,
-        unordered_set<T, H, P, A> const&);
-    template <class T, class H, class P, class A>
-    void swap(unordered_set<T, H, P, A> &m1,
-            unordered_set<T, H, P, A> &m2);
-
-    template <class Value,
-        class Hash = hash<Value>,
-        class Pred = std::equal_to<Value>,
-        class Alloc = std::allocator<Value> >
-    class unordered_multiset;
-    template <class T, class H, class P, class A>
-    bool operator==(unordered_multiset<T, H, P, A> const&,
-        unordered_multiset<T, H, P, A> const&);
-    template <class T, class H, class P, class A>
-    bool operator!=(unordered_multiset<T, H, P, A> const&,
-        unordered_multiset<T, H, P, A> const&);
-    template <class T, class H, class P, class A>
-    void swap(unordered_multiset<T, H, P, A> &m1,
-            unordered_multiset<T, H, P, A> &m2);
-
-    template <class Value, class Hash, class Pred, class Alloc>
-    class unordered_set
-    {
-        typedef boost::unordered_detail::hash_types_unique_keys<
-            Value, Value, Hash, Pred, Alloc
-        > implementation;
-
-        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
-
-    public:
-
-        // types
-
-        typedef Value key_type;
-        typedef Value value_type;
-        typedef Hash hasher;
-        typedef Pred key_equal;
-
-        typedef Alloc allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
-        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
-
-        // construct/destroy/copy
-
-        explicit unordered_set(
-                size_type n = boost::unordered_detail::default_initial_bucket_count,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-            : base(n, hf, eql, a)
-        {
-        }
-
-        explicit unordered_set(allocator_type const& a)
-            : base(boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), a)
-        {
-        }
-
-        unordered_set(unordered_set const& other, allocator_type const& a)
-            : base(other.base, a)
-        {
-        }
-
-        template <class InputIterator>
-        unordered_set(InputIterator f, InputIterator l)
-            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_set(InputIterator f, InputIterator l, size_type n,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-            : base(f, l, n, hf, eql, a)
-        {
-        }
-
-#if defined(BOOST_HAS_RVALUE_REFS)
-        unordered_set(unordered_set&& other)
-            : base(other.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_set(unordered_set&& other, allocator_type const& a)
-            : base(other.base, a, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_set& operator=(unordered_set&& x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#else
-        unordered_set(boost::unordered_detail::move_from<unordered_set<Value, Hash, Pred, Alloc> > other)
-            : base(other.source.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
-        unordered_set& operator=(unordered_set x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#endif
-#endif
-
-    private:
-
-        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
-            get(const_iterator const& it)
-        {
-            return boost::unordered_detail::iterator_access::get(it);
-        }
-
-    public:
-
-        allocator_type get_allocator() const
-        {
-            return base.get_allocator();
-        }
-
-        // size and capacity
-
-        bool empty() const
-        {
-            return base.empty();
-        }
-
-        size_type size() const
-        {
-            return base.size();
-        }
-
-        size_type max_size() const
-        {
-            return base.max_size();
-        }
-
-        // iterators
-
-        iterator begin()
-        {
-            return iterator(base.data_.begin());
-        }
-
-        const_iterator begin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        iterator end()
-        {
-            return iterator(base.data_.end());
-        }
-
-        const_iterator end() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        const_iterator cbegin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        const_iterator cend() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        // modifiers
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template <class... Args>
-        std::pair<iterator, bool> emplace(Args&&... args)
-        {
-            return boost::unordered_detail::pair_cast<iterator, bool>(
-                base.insert(std::forward<Args>(args)...));
-        }
-
-        template <class... Args>
-        iterator emplace(const_iterator hint, Args&&... args)
-        {
-            return iterator(
-                base.insert_hint(get(hint), std::forward<Args>(args)...));
-        }
-#endif
-
-        std::pair<iterator, bool> insert(const value_type& obj)
-        {
-            return boost::unordered_detail::pair_cast<iterator, bool>(
-                    base.insert(obj));
-        }
-
-        iterator insert(const_iterator hint, const value_type& obj)
-        {
-            return iterator(base.insert_hint(get(hint), obj));
-        }
-
-        template <class InputIterator>
-            void insert(InputIterator first, InputIterator last)
-        {
-            base.insert_range(first, last);
-        }
-
-        iterator erase(const_iterator position)
-        {
-            return iterator(base.data_.erase(get(position)));
-        }
-
-        size_type erase(const key_type& k)
-        {
-            return base.erase_key(k);
-        }
-
-        iterator erase(const_iterator first, const_iterator last)
-        {
-            return iterator(base.data_.erase_range(get(first), get(last)));
-        }
-
-        void clear()
-        {
-            base.data_.clear();
-        }
-
-        void swap(unordered_set& other)
-        {
-            base.swap(other.base);
-        }
-
-        // observers
-
-        hasher hash_function() const
-        {
-            return base.hash_function();
-        }
-
-        key_equal key_eq() const
-        {
-            return base.key_eq();
-        }
-
-        // lookup
-
-        const_iterator find(const key_type& k) const
-        {
-            return const_iterator(base.find(k));
-        }
-
-        size_type count(const key_type& k) const
-        {
-            return base.count(k);
-        }
-
-        std::pair<const_iterator, const_iterator>
-            equal_range(const key_type& k) const
-        {
-            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
-                    base.equal_range(k));
-        }
-
-        // bucket interface
-
-        size_type bucket_count() const
-        {
-            return base.bucket_count();
-        }
-
-        size_type max_bucket_count() const
-        {
-            return base.max_bucket_count();
-        }
-
-        size_type bucket_size(size_type n) const
-        {
-            return base.data_.bucket_size(n);
-        }
-
-        size_type bucket(const key_type& k) const
-        {
-            return base.bucket(k);
-        }
-
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        local_iterator end(size_type n)
-        {
-            return local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator end(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator cend(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        // hash policy
-
-        float load_factor() const
-        {
-            return base.load_factor();
-        }
-
-        float max_load_factor() const
-        {
-            return base.max_load_factor();
-        }
-
-        void max_load_factor(float m)
-        {
-            base.max_load_factor(m);
-        }
-
-        void rehash(size_type n)
-        {
-            base.rehash(n);
-        }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        friend bool operator==(unordered_set const&, unordered_set const&);
-        friend bool operator!=(unordered_set const&, unordered_set const&);
-#else
-        friend bool operator==<>(unordered_set const&, unordered_set const&);
-        friend bool operator!=<>(unordered_set const&, unordered_set const&);
-#endif
-    }; // class template unordered_set
-
-    template <class T, class H, class P, class A>
-    inline bool operator==(unordered_set<T, H, P, A> const& m1,
-        unordered_set<T, H, P, A> const& m2)
-    {
-        return boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class T, class H, class P, class A>
-    inline bool operator!=(unordered_set<T, H, P, A> const& m1,
-        unordered_set<T, H, P, A> const& m2)
-    {
-        return !boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class T, class H, class P, class A>
-    inline void swap(unordered_set<T, H, P, A> &m1,
-            unordered_set<T, H, P, A> &m2)
-    {
-        m1.swap(m2);
-    }
-
-    template <class Value, class Hash, class Pred, class Alloc>
-    class unordered_multiset
-    {
-        typedef boost::unordered_detail::hash_types_equivalent_keys<
-            Value, Value, Hash, Pred, Alloc
-        > implementation;
-
-        BOOST_DEDUCED_TYPENAME implementation::hash_table base;
-
-    public:
-
-        //types
-
-        typedef Value key_type;
-        typedef Value value_type;
-        typedef Hash hasher;
-        typedef Pred key_equal;
-
-        typedef Alloc allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
-        typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
-        typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
-
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
-
-        // construct/destroy/copy
-
-        explicit unordered_multiset(
-                size_type n = boost::unordered_detail::default_initial_bucket_count,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-          : base(n, hf, eql, a)
-        {
-        }
-
-        explicit unordered_multiset(allocator_type const& a)
-            : base(boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), a)
-        {
-        }
-
-        unordered_multiset(unordered_multiset const& other, allocator_type const& a)
-            : base(other.base, a)
-        {
-        }
-
-        template <class InputIterator>
-        unordered_multiset(InputIterator f, InputIterator l)
-            : base(f, l, boost::unordered_detail::default_initial_bucket_count,
-                hasher(), key_equal(), allocator_type())
-        {
-        }
-
-        template <class InputIterator>
-        unordered_multiset(InputIterator f, InputIterator l, size_type n,
-                const hasher &hf = hasher(),
-                const key_equal &eql = key_equal(),
-                const allocator_type &a = allocator_type())
-          : base(f, l, n, hf, eql, a)
-        {
-        }
-
-#if defined(BOOST_HAS_RVALUE_REFS)
-        unordered_multiset(unordered_multiset&& other)
-            : base(other.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_multiset(unordered_multiset&& other, allocator_type const& a)
-            : base(other.base, a, boost::unordered_detail::move_tag())
-        {
-        }
-
-        unordered_multiset& operator=(unordered_multiset&& x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#else
-        unordered_multiset(boost::unordered_detail::move_from<unordered_multiset<Value, Hash, Pred, Alloc> > other)
-            : base(other.source.base, boost::unordered_detail::move_tag())
-        {
-        }
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
-        unordered_multiset& operator=(unordered_multiset x)
-        {
-            base.move(x.base);
-            return *this;
-        }
-#endif
-#endif
-
-    private:
-
-        BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
-            get(const_iterator const& it)
-        {
-            return boost::unordered_detail::iterator_access::get(it);
-        }
-
-    public:
-
-        allocator_type get_allocator() const
-        {
-            return base.get_allocator();
-        }
-
-        // size and capacity
-
-        bool empty() const
-        {
-            return base.empty();
-        }
-
-        size_type size() const
-        {
-            return base.size();
-        }
-
-        size_type max_size() const
-        {
-            return base.max_size();
-        }
-
-        // iterators
-
-        iterator begin()
-        {
-            return iterator(base.data_.begin());
-        }
-
-        const_iterator begin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        iterator end()
-        {
-            return iterator(base.data_.end());
-        }
-
-        const_iterator end() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        const_iterator cbegin() const
-        {
-            return const_iterator(base.data_.begin());
-        }
-
-        const_iterator cend() const
-        {
-            return const_iterator(base.data_.end());
-        }
-
-        // modifiers
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-        template <class... Args>
-        iterator emplace(Args&&... args)
-        {
-            return iterator(base.insert(std::forward<Args>(args)...));
-        }
-
-        template <class... Args>
-        iterator emplace(const_iterator hint, Args&&... args)
-        {
-            return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
-        }
-#endif
-
-        iterator insert(const value_type& obj)
-        {
-            return iterator(base.insert(obj));
-        }
-
-        iterator insert(const_iterator hint, const value_type& obj)
-        {
-            return iterator(base.insert_hint(get(hint), obj));
-        }
-
-        template <class InputIterator>
-            void insert(InputIterator first, InputIterator last)
-        {
-            base.insert_range(first, last);
-        }
-
-        iterator erase(const_iterator position)
-        {
-            return iterator(base.data_.erase(get(position)));
-        }
-
-        size_type erase(const key_type& k)
-        {
-            return base.erase_key(k);
-        }
-
-        iterator erase(const_iterator first, const_iterator last)
-        {
-            return iterator(base.data_.erase_range(get(first), get(last)));
-        }
-
-        void clear()
-        {
-            base.data_.clear();
-        }
-
-        void swap(unordered_multiset& other)
-        {
-            base.swap(other.base);
-        }
-
-        // observers
-
-        hasher hash_function() const
-        {
-            return base.hash_function();
-        }
-
-        key_equal key_eq() const
-        {
-            return base.key_eq();
-        }
-
-        // lookup
-
-        const_iterator find(const key_type& k) const
-        {
-            return const_iterator(base.find(k));
-        }
-
-        size_type count(const key_type& k) const
-        {
-            return base.count(k);
-        }
-
-        std::pair<const_iterator, const_iterator>
-            equal_range(const key_type& k) const
-        {
-            return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
-                    base.equal_range(k));
-        }
-
-        // bucket interface
-
-        size_type bucket_count() const
-        {
-            return base.bucket_count();
-        }
-
-        size_type max_bucket_count() const
-        {
-            return base.max_bucket_count();
-        }
-
-        size_type bucket_size(size_type n) const
-        {
-            return base.data_.bucket_size(n);
-        }
-
-        size_type bucket(const key_type& k) const
-        {
-            return base.bucket(k);
-        }
-
-        local_iterator begin(size_type n)
-        {
-            return local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator begin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        local_iterator end(size_type n)
-        {
-            return local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator end(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        const_local_iterator cbegin(size_type n) const
-        {
-            return const_local_iterator(base.data_.begin(n));
-        }
-
-        const_local_iterator cend(size_type n) const
-        {
-            return const_local_iterator(base.data_.end(n));
-        }
-
-        // hash policy
-
-        float load_factor() const
-        {
-            return base.load_factor();
-        }
-
-        float max_load_factor() const
-        {
-            return base.max_load_factor();
-        }
-
-        void max_load_factor(float m)
-        {
-            base.max_load_factor(m);
-        }
-
-        void rehash(size_type n)
-        {
-            base.rehash(n);
-        }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        friend bool operator==(unordered_multiset const&, unordered_multiset const&);
-        friend bool operator!=(unordered_multiset const&, unordered_multiset const&);
-#else
-        friend bool operator==<>(unordered_multiset const&, unordered_multiset const&);
-        friend bool operator!=<>(unordered_multiset const&, unordered_multiset const&);
-#endif
-    }; // class template unordered_multiset
-
-    template <class T, class H, class P, class A>
-    inline bool operator==(unordered_multiset<T, H, P, A> const& m1,
-        unordered_multiset<T, H, P, A> const& m2)
-    {
-        return boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class T, class H, class P, class A>
-    inline bool operator!=(unordered_multiset<T, H, P, A> const& m1,
-        unordered_multiset<T, H, P, A> const& m2)
-    {
-        return !boost::unordered_detail::equals(m1.base, m2.base);
-    }
-
-    template <class T, class H, class P, class A>
-    inline void swap(unordered_multiset<T, H, P, A> &m1,
-            unordered_multiset<T, H, P, A> &m2)
-    {
-        m1.swap(m2);
-    }
-
-} // namespace boost
+#include <boost/unordered/unordered_set.hpp>
 
 #endif // BOOST_UNORDERED_SET_HPP_INCLUDED

module.cmake

@@ -0,0 +1 @@
+boost_module(unordered DEPENDS config functional)

test/CMakeLists.txt

@@ -0,0 +1,75 @@
+boost_additional_test_dependencies(unordered BOOST_DEPENDS test)
+
+# GCC Compilers
+IF(CMAKE_COMPILER_IS_GNUCC)
+  SET(test_compile_flags "-Wsign-promo -Wunused-parameter")
+ENDIF(CMAKE_COMPILER_IS_GNUCC)
+
+# Intel Compiler flags
+IF( ${CMAKE_CXX_COMPILER} MATCHES "icpc" )
+    SET(test_compile_flags "${test_compile_flags} -strict_ansi -cxxlib-icc")  
+ENDIF( ${CMAKE_CXX_COMPILER} MATCHES "icpc" )
+
+set (swap_compile_flags "${test_compile_flags} -DBOOST_UNORDERED_SWAP_METHOD=2")
+
+#-------------------------------------------------------------------------------
+# Unordered Tests
+set (unordered_tests
+        fwd_set_test
+        fwd_map_test
+        compile_set
+        compile_map
+        link_test_1
+         link_test_2
+        simple_tests
+        equivalent_keys_tests
+        constructor_tests
+        copy_tests
+        move_tests.cpp 
+        assign_tests
+        insert_tests
+        insert_stable_tests
+        unnecessary_copy_tests
+        erase_tests
+        erase_equiv_tests
+        find_tests
+        at_tests
+        bucket_tests
+        load_factor_tests
+        rehash_tests
+        equality_tests
+)
+#-- Create an executable test for each source
+foreach(test ${unordered_tests})
+    boost_test_run(${test} "unordered/${test}.cpp"
+                    COMPILE_FLAGS ${test_compile_flags} 
+                    DEPENDS boost_unit_test_framework) 
+endforeach(test ${unordered_tests})
+
+#-- run the swap test
+boost_test_run(swap_tests 
+                COMPILE_FLAGS ${swap_compile_flags} 
+                DEPENDS boost_unit_test_framework)
+
+#-------------------------------------------------------------------------------
+# Exception Tests
+set (exception_tests
+    constructor_exception_tests
+    copy_exception_tests
+    assign_exception_tests
+    insert_exception_tests
+    erase_exception_tests
+    rehash_exception_tests
+)
+
+#-- Create an executable test for each source
+foreach(test ${exception_tests})
+    boost_test_run(${test} "exception/${test}.cpp"
+                    COMPILE_FLAGS ${test_compile_flags} 
+                    DEPENDS boost_unit_test_framework) 
+endforeach(test ${unordered_tests})
+
+#-- run the swap test
+boost_test_run(swap_swap_exception_tests 
+                COMPILE_FLAGS ${swap_compile_flags} 
+                DEPENDS boost_unit_test_framework)

test/objects/minimal.hpp

@@ -240,7 +240,7 @@ namespace minimal
         size_type max_size() const { return 1000; }
 
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) || \
-        BOOST_WORKAROUND(MSVC, <= 1300)
+        BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
     public: allocator& operator=(allocator const&) { return *this;}
 #else
     private: allocator& operator=(allocator const&);

test/unordered/Jamfile.v2

@@ -14,6 +14,8 @@ project unordered-test/unordered
 
 test-suite unordered
     :
+        [ run fwd_set_test.cpp ]
+        [ run fwd_map_test.cpp ]
         [ run compile_set.cpp ]
         [ run compile_map.cpp ]
         [ run link_test_1.cpp link_test_2.cpp ]

test/unordered/assign_tests.cpp

@@ -103,6 +103,22 @@ UNORDERED_TEST(assign_tests2,
     ((default_generator)(generate_collisions))
 )
 
+#if !defined(BOOST_NO_INITIALIZER_LISTS)
+
+UNORDERED_AUTO_TEST(assign_initializer_list)
+{
+    std::cerr<<"Initializer List Tests\n";
+
+    boost::unordered_set<int> x;
+    x.insert(10);
+    x.insert(20);
+    x = { 1, 2, -10 };
+    BOOST_CHECK(x.find(10) == x.end());
+    BOOST_CHECK(x.find(-10) != x.end());
+}
+
+#endif
+
 }
 
 RUN_TESTS()

test/unordered/compile_tests.hpp

@@ -290,7 +290,7 @@ void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
     const_iterator q = a.cbegin();
     test::check_return_type<iterator>::equals(a.insert(q, t));
 #if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-    test::check_return_type<iterator>::equals(a.emplace(q, t));
+    test::check_return_type<iterator>::equals(a.emplace_hint(q, t));
 #endif
 
     a.insert(i, j);

test/unordered/constructor_tests.cpp

@@ -288,6 +288,17 @@ UNORDERED_TEST(map_constructor_test,
     ((test_map)(test_multimap))
 )
 
+#if !defined(BOOST_NO_INITIALIZER_LISTS)
+
+UNORDERED_AUTO_TEST(test_initializer_list) {
+    std::cerr<<"Initializer List Tests\n";
+    boost::unordered_set<int> x1 = { 2, 10, 45, -5 };
+    BOOST_CHECK(x1.find(10) != x1.end());
+    BOOST_CHECK(x1.find(46) == x1.end());
+}
+
+#endif
+
 }
 
 RUN_TESTS()

test/unordered/equality_tests.cpp

@@ -13,6 +13,10 @@ namespace equality_tests
 {
     struct mod_compare
     {
+        bool alt_hash_;
+
+        explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
+
         bool operator()(int x, int y) const
         {
             return x % 1000 == y % 1000;
@@ -20,7 +24,7 @@ namespace equality_tests
 
         int operator()(int x) const
         {
-            return x % 250;
+            return alt_hash_ ? x % 250 : (x + 5) % 250;
         }
     };
 
@@ -138,6 +142,25 @@ namespace equality_tests
             ((1)(2))((1001)(1)), ==, ((1001)(2))((1)(1)));
     }
 
+    // Test that equality still works when the two containers have
+    // different hash functions but the same equality predicate.
+
+    UNORDERED_AUTO_TEST(equality_different_hash_test)
+    {
+        typedef boost::unordered_set<int, mod_compare, mod_compare> set;
+        set set1(0, mod_compare(false), mod_compare(false));
+        set set2(0, mod_compare(true), mod_compare(true));
+        BOOST_CHECK(set1 == set2);
+        set1.insert(1); set2.insert(2);
+        BOOST_CHECK(set1 != set2);
+        set1.insert(2); set2.insert(1);
+        BOOST_CHECK(set1 == set2);
+        set1.insert(10); set2.insert(20);
+        BOOST_CHECK(set1 != set2);
+        set1.insert(20); set2.insert(10);
+        BOOST_CHECK(set1 == set2);
+    }
+
 }
 
 RUN_TESTS()

test/unordered/fwd_map_test.cpp

@@ -0,0 +1,62 @@
+
+// Copyright 2008 Daniel James.
+// 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)
+
+#include <boost/unordered/unordered_map_fwd.hpp>
+
+typedef boost::unordered_map<int, int> int_map;
+
+void call_swap(int_map& x, int_map& y) {
+    swap(x,y);
+}
+
+bool call_equals(int_map& x, int_map& y) {
+    return x == y;
+}
+
+bool call_not_equals(int_map& x, int_map& y) {
+    return x != y;
+}
+
+typedef boost::unordered_multimap<int, int> int_multimap;
+
+void call_swap(int_multimap& x, int_multimap& y) {
+    swap(x,y);
+}
+
+bool call_equals(int_multimap& x, int_multimap& y) {
+    return x == y;
+}
+
+bool call_not_equals(int_multimap& x, int_multimap& y) {
+    return x != y;
+}
+
+#include <boost/unordered_map.hpp>
+#include "../helpers/test.hpp"
+
+UNORDERED_AUTO_TEST(use_map_fwd_declared_function) {
+    int_map x, y;
+    x[1] = 2;
+    y[2] = 1;
+    call_swap(x, y);
+
+    BOOST_CHECK(y.find(1) != y.end() && y.find(1)->second == 2);
+    BOOST_CHECK(y.find(2) == y.end());
+
+    BOOST_CHECK(x.find(1) == x.end());
+    BOOST_CHECK(x.find(2) != x.end() && x.find(2)->second == 1);
+
+    BOOST_CHECK(!call_equals(x, y));
+    BOOST_CHECK(call_not_equals(x, y));
+}
+
+UNORDERED_AUTO_TEST(use_multimap_fwd_declared_function) {
+    int_multimap x, y;
+    call_swap(x, y);
+    BOOST_CHECK(call_equals(x, y));
+    BOOST_CHECK(!call_not_equals(x, y));
+}
+
+RUN_TESTS()

test/unordered/fwd_set_test.cpp

@@ -0,0 +1,84 @@
+
+// Copyright 2008 Daniel James.
+// 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)
+
+#include <boost/unordered/unordered_set_fwd.hpp>
+
+struct true_type { char x[100]; };
+struct false_type { char x; };
+
+false_type is_unordered_set_impl(void*);
+
+template <class Value, class Hash, class Pred, class Alloc>
+true_type is_unordered_set_impl(
+        boost::unordered_set<Value, Hash, Pred, Alloc>*);
+
+typedef boost::unordered_set<int> int_set;
+
+void call_swap(int_set& x, int_set& y) {
+    swap(x,y);
+}
+
+bool call_equals(int_set& x, int_set& y) {
+    return x == y;
+}
+
+bool call_not_equals(int_set& x, int_set& y) {
+    return x != y;
+}
+
+typedef boost::unordered_multiset<int> int_multiset;
+
+void call_swap(int_multiset& x, int_multiset& y) {
+    swap(x,y);
+}
+
+bool call_equals(int_multiset& x, int_multiset& y) {
+    return x == y;
+}
+
+bool call_not_equals(int_multiset& x, int_multiset& y) {
+    return x != y;
+}
+
+#include "../helpers/test.hpp"
+
+UNORDERED_AUTO_TEST(use_fwd_declared_trait_without_definition) {
+    BOOST_CHECK(sizeof(is_unordered_set_impl((int_set*) 0)) == sizeof(true_type));
+}
+
+#include <boost/unordered_set.hpp>
+
+UNORDERED_AUTO_TEST(use_fwd_declared_trait) {
+    boost::unordered_set<int> x;
+    BOOST_CHECK(sizeof(is_unordered_set_impl(&x)) == sizeof(true_type));
+
+    int dummy;
+    BOOST_CHECK(sizeof(is_unordered_set_impl(&dummy)) == sizeof(false_type));
+}
+
+UNORDERED_AUTO_TEST(use_set_fwd_declared_function) {
+    int_set x, y;
+    x.insert(1);
+    y.insert(2);
+    call_swap(x, y);
+
+    BOOST_CHECK(y.find(1) != y.end());
+    BOOST_CHECK(y.find(2) == y.end());
+
+    BOOST_CHECK(x.find(1) == x.end());
+    BOOST_CHECK(x.find(2) != x.end());
+
+    BOOST_CHECK(!call_equals(x, y));
+    BOOST_CHECK(call_not_equals(x, y));
+}
+
+UNORDERED_AUTO_TEST(use_multiset_fwd_declared_function) {
+    int_multiset x, y;
+    call_swap(x, y);
+    BOOST_CHECK(call_equals(x, y));
+    BOOST_CHECK(!call_not_equals(x, y));
+}
+
+RUN_TESTS()