Check in unordered associative containers. I haven't looked at these for ages

but they pass my unit tests so they should be okay.


[SVN r2585]

include/boost/unordered/detail/allocator.hpp

@@ -0,0 +1,152 @@
+//  (C) Copyright Daniel James 2005.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_ALLOCATOR_UTILITIES_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/detail/allocator_utilities.hpp>
+#include <boost/mpl/aux_/config/eti.hpp>
+
+namespace boost {
+    namespace unordered_detail {
+
+        // Work around for Microsoft's ETI bug.
+        
+        template <class Allocator> struct get_value_type
+        {
+            typedef typename Allocator::value_type type;
+        };
+
+        template <class Allocator> struct get_pointer
+        {
+            typedef typename Allocator::pointer type;
+        };
+        
+        template <class Allocator> struct get_const_pointer
+        {
+            typedef typename Allocator::const_pointer type;
+        };
+        
+        template <class Allocator> struct get_reference
+        {
+            typedef typename Allocator::reference type;
+        };
+        
+        template <class Allocator> struct get_const_reference
+        {
+            typedef typename Allocator::const_reference type;
+        };
+        
+        #if defined(BOOST_MPL_CFG_MSVC_ETI_BUG)
+
+        template <>
+        struct get_value_type<int>
+        {
+            typedef int type;
+        };
+
+        template <>
+        struct get_pointer<int>
+        {
+            typedef int type;
+        };
+
+        template <>
+        struct get_const_pointer<int>
+        {
+            typedef int type;
+        };
+
+        template <>
+        struct get_reference<int>
+        {
+            typedef int type;
+        };
+
+        template <>
+        struct get_const_reference<int>
+        {
+            typedef int type;
+        };
+
+        #endif
+
+        template <class Allocator>
+        struct allocator_constructor
+        {
+            typedef typename get_pointer<Allocator>::type pointer;
+
+            Allocator& alloc_;
+            pointer ptr_;
+
+            allocator_constructor(Allocator& a)
+                : alloc_(a), ptr_() {}
+
+            ~allocator_constructor() {
+                if (ptr_) alloc_.deallocate(ptr_, 1);
+            }
+
+            template <class V>
+            pointer construct(V const& v) {
+                pointer p = alloc_.allocate(1);
+                ptr_ = p;
+                alloc_.construct(p, v);
+                ptr_ = pointer();
+                return p;
+            }
+        };
+
+        template <class Allocator>
+        struct allocator_array_constructor
+        {
+            typedef typename get_pointer<Allocator>::type pointer;
+
+            Allocator& alloc_;
+            pointer ptr_;
+            pointer constructed_;
+            std::size_t length_;
+
+            allocator_array_constructor(Allocator& a)
+                : alloc_(a), ptr_(), constructed_(), length_(0) {}
+
+            ~allocator_array_constructor() {
+                if (ptr_) {
+                    for(pointer p = ptr_; p != constructed_; ++p)
+                        alloc_.destroy(p);
+
+                    alloc_.deallocate(ptr_, length_);
+                }
+            }
+
+            template <class V>
+            void construct(V const& v, std::size_t l)
+            {
+                length_ = l;
+                ptr_ = alloc_.allocate(length_);
+                pointer end = ptr_ + length_;
+                for(constructed_ = ptr_; constructed_ != end; ++constructed_)
+                    alloc_.construct(constructed_, v);
+            }
+
+            pointer get() const
+            {
+                return ptr_;
+            }
+
+            pointer release()
+            {
+                pointer p(ptr_);
+                ptr_ = pointer();
+                return p;
+            }
+        };
+    }
+}
+
+#endif

include/boost/unordered_map.hpp

@@ -0,0 +1,593 @@
+
+// JTC1/SC22/WG21 N1456 Hash table implementation
+// http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1456.html
+
+// boost/unordered_map.hpp
+
+// Copyright <20> 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright <20> 2005 Daniel James.
+
+// Use, modification, and distribution is subject to 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_HPP_INCLUDED
+#define BOOST_UNORDERED_MAP_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <functional>
+#include <memory>
+
+#include <boost/unordered/detail/hash_table.hpp>
+#include <boost/functional/hash.hpp>
+
+namespace boost
+{
+    //! An unordered associative container that associates unique keys with another value.
+    /*! For full details see section 6.3.4.4 of the Technical report.
+     *  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1745.pdf
+     */
+
+    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
+    {
+        // Named for the benefit of Doxygen.
+        typedef boost::unordered_detail::hash_types<
+            std::pair<const Key, T>, Key, Hash,
+            Pred, Alloc, false
+        > implementation_defined;
+
+        typename implementation_defined::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;
+
+        // This version can be used when compiling against CVS.
+        typedef Alloc allocator_type;
+        typedef typename allocator_type::pointer pointer;
+        typedef typename allocator_type::const_pointer const_pointer;
+        typedef typename allocator_type::reference reference;
+        typedef typename allocator_type::const_reference const_reference;
+
+        typedef typename implementation_defined::size_type size_type;
+        typedef typename implementation_defined::difference_type difference_type;
+
+        typedef typename implementation_defined::iterator iterator;
+        typedef typename implementation_defined::const_iterator const_iterator;
+        typedef typename implementation_defined::local_iterator local_iterator;
+        typedef typename implementation_defined::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)
+        {
+        }
+
+        template <class InputIterator>
+        unordered_map(InputIterator f, InputIterator l,
+                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(f, l, n, hf, eql, a)
+        {
+        }
+
+    private:
+
+        typename implementation_defined::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.begin());
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator(base.begin());
+        }
+
+        iterator end()
+        {
+            return iterator(base.end());
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator(base.end());
+        }
+
+        // modifiers
+
+        std::pair<iterator, bool> insert(const value_type& obj)
+        {
+            return boost::unordered_detail::pair_cast<iterator, bool>(
+                    base.insert_unique(obj));
+        }
+
+        iterator insert(const_iterator hint, const value_type& obj)
+        {
+            return iterator(base.insert_unique(get(hint), obj));
+        }
+
+        template <class InputIterator>
+            void insert(InputIterator first, InputIterator last)
+        {
+            base.insert(first, last);
+        }
+
+        iterator erase(const_iterator position)
+        {
+            return iterator(base.erase(get(position)));
+        }
+
+        size_type erase(const key_type& k)
+        {
+            return base.erase(k);
+        }
+
+        iterator erase(const_iterator first, const_iterator last)
+        {
+            return iterator(base.erase(get(first), get(last)));
+        }
+
+        void clear()
+        {
+            base.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;
+        }
+
+        // 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.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.begin(n));
+        }
+
+        const_local_iterator begin(size_type n) const
+        {
+            return const_local_iterator(base.begin(n));
+        }
+
+        local_iterator end(size_type n)
+        {
+            return local_iterator(base.end(n));
+        }
+
+        const_local_iterator end(size_type n) const
+        {
+            return const_local_iterator(base.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);
+        }
+    }; // class template unordered_map
+
+    template <class K, class T, class H, class P, class A>
+    void swap(unordered_map<K, T, H, P, A> &m1,
+            unordered_map<K, T, H, P, A> &m2)
+    {
+        m1.swap(m2);
+    }
+
+    //! An unordered associative container that associates equivalent keys with another value.
+    /*! For full details see section 6.3.4.6 of the Technical report.
+     *  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1745.pdf
+     */
+
+    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
+    {
+        // Named for the benefit of Doxygen.
+        typedef boost::unordered_detail::hash_types<
+            std::pair<const Key, T>, Key, Hash,
+            Pred, Alloc, true
+        > implementation_defined;
+
+        typename implementation_defined::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;
+
+        // This version can be used when compiling against CVS.
+
+        typedef Alloc allocator_type;
+        typedef typename allocator_type::pointer pointer;
+        typedef typename allocator_type::const_pointer const_pointer;
+        typedef typename allocator_type::reference reference;
+        typedef typename allocator_type::const_reference const_reference;
+
+        typedef typename implementation_defined::size_type size_type;
+        typedef typename implementation_defined::difference_type difference_type;
+
+        typedef typename implementation_defined::iterator iterator;
+        typedef typename implementation_defined::const_iterator const_iterator;
+        typedef typename implementation_defined::local_iterator local_iterator;
+        typedef typename implementation_defined::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)
+        {
+        }
+
+        template <class InputIterator>
+        unordered_multimap(InputIterator f, InputIterator l,
+                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(f, l, n, hf, eql, a)
+        {
+        }
+
+    private:
+
+        typename implementation_defined::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.begin());
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator(base.begin());
+        }
+
+        iterator end()
+        {
+            return iterator(base.end());
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator(base.end());
+        }
+
+        // modifiers
+
+        iterator insert(const value_type& obj)
+        {
+            return iterator(base.insert_equivalent(obj));
+        }
+
+        iterator insert(const_iterator hint, const value_type& obj)
+        {
+            return iterator(base.insert_equivalent(get(hint), obj));
+        }
+
+        template <class InputIterator>
+            void insert(InputIterator first, InputIterator last)
+        {
+            base.insert(first, last);
+        }
+
+        iterator erase(const_iterator position)
+        {
+            return iterator(base.erase(get(position)));
+        }
+
+        size_type erase(const key_type& k)
+        {
+            return base.erase(k);
+        }
+
+        iterator erase(const_iterator first, const_iterator last)
+        {
+            return iterator(base.erase(get(first), get(last)));
+        }
+
+        void clear()
+        {
+            base.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.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.begin(n));
+        }
+
+        const_local_iterator begin(size_type n) const
+        {
+            return const_local_iterator(base.begin(n));
+        }
+
+        local_iterator end(size_type n)
+        {
+            return local_iterator(base.end(n));
+        }
+
+        const_local_iterator end(size_type n) const
+        {
+            return const_local_iterator(base.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);
+        }
+    }; // class template unordered_multimap
+
+    template <class K, class T, class H, class P, class A>
+    void swap(unordered_multimap<K, T, H, P, A> &m1,
+            unordered_multimap<K, T, H, P, A> &m2)
+    {
+        m1.swap(m2);
+    }
+
+} // namespace boost
+
+#endif // BOOST_UNORDERED_MAP_HPP_INCLUDED

include/boost/unordered_set.hpp

@@ -0,0 +1,581 @@
+
+// JTC1/SC22/WG21 N1456 Hash table implementation
+// http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1456.html
+
+// boost/unordered_set.hpp
+
+// Copyright <20> 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright <20> 2005 Daniel James.
+
+// Use, modification, and distribution is subject to 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_HPP_INCLUDED
+#define BOOST_UNORDERED_SET_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <functional>
+#include <memory>
+
+#include <boost/unordered/detail/hash_table.hpp>
+#include <boost/functional/hash.hpp>
+
+namespace boost
+{
+    //! An unordered associative container that stores unique values.
+    /*! For full details see section 6.3.4.3 of the Technical report.
+     *  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1745.pdf
+     */
+
+    template <class Value,
+        class Hash = hash<Value>,
+        class Pred = std::equal_to<Value>,
+        class Alloc = std::allocator<Value> >
+    class unordered_set
+    {
+        // Named for the benefit of Doxygen.
+        typedef boost::unordered_detail::hash_types<
+            Value, Value, Hash,
+            Pred, Alloc, false
+        > implementation_defined;
+
+        typename implementation_defined::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 typename allocator_type::pointer pointer;
+        typedef typename allocator_type::const_pointer const_pointer;
+        typedef typename allocator_type::reference reference;
+        typedef typename allocator_type::const_reference const_reference;
+
+        typedef typename implementation_defined::size_type size_type;
+        typedef typename implementation_defined::difference_type difference_type;
+
+        typedef typename implementation_defined::const_iterator iterator;
+        typedef typename implementation_defined::const_iterator const_iterator;
+        typedef typename implementation_defined::const_local_iterator local_iterator;
+        typedef typename implementation_defined::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)
+        {
+        }
+
+        template <class InputIterator>
+        unordered_set(InputIterator f, InputIterator l,
+                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(f, l, n, hf, eql, a)
+        {
+        }
+
+    private:
+
+        typename implementation_defined::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.begin());
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator(base.begin());
+        }
+
+        iterator end()
+        {
+            return iterator(base.end());
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator(base.end());
+        }
+
+        // modifiers
+
+        std::pair<iterator, bool> insert(const value_type& obj)
+        {
+            return boost::unordered_detail::pair_cast<iterator, bool>(
+                    base.insert_unique(obj));
+        }
+
+        iterator insert(const_iterator hint, const value_type& obj)
+        {
+            return iterator(base.insert_unique(get(hint), obj));
+        }
+
+        template <class InputIterator>
+            void insert(InputIterator first, InputIterator last)
+        {
+            base.insert(first, last);
+        }
+
+        iterator erase(const_iterator position)
+        {
+            return iterator(base.erase(get(position)));
+        }
+
+        size_type erase(const key_type& k)
+        {
+            return base.erase(k);
+        }
+
+        iterator erase(const_iterator first, const_iterator last)
+        {
+            return iterator(base.erase(get(first), get(last)));
+        }
+
+        void clear()
+        {
+            base.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
+
+        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.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.begin(n));
+        }
+
+        const_local_iterator begin(size_type n) const
+        {
+            return local_iterator(base.begin(n));
+        }
+
+        local_iterator end(size_type n)
+        {
+            return local_iterator(base.end(n));
+        }
+
+        const_local_iterator end(size_type n) const
+        {
+            return const_local_iterator(base.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);
+        }
+    }; // class template unordered_set
+
+    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)
+    {
+        m1.swap(m2);
+    }
+
+    //! An unordered associative container that stores equivalent values.
+    /*! For full details see section 6.3.4.5 of the Technical report.
+     *  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1745.pdf
+     */
+
+    template <class Value,
+        class Hash = hash<Value>,
+        class Pred = std::equal_to<Value>,
+        class Alloc = std::allocator<Value> >
+    class unordered_multiset
+    {
+        // Named for the benefit of Doxygen.
+        typedef boost::unordered_detail::hash_types<
+            Value, Value, Hash,
+            Pred, Alloc, true
+        > implementation_defined;
+
+        typename implementation_defined::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 typename allocator_type::pointer pointer;
+        typedef typename allocator_type::const_pointer const_pointer;
+        typedef typename allocator_type::reference reference;
+        typedef typename allocator_type::const_reference const_reference;
+
+        typedef typename implementation_defined::size_type size_type;
+        typedef typename implementation_defined::difference_type difference_type;
+
+        typedef typename implementation_defined::const_iterator iterator;
+        typedef typename implementation_defined::const_iterator const_iterator;
+        typedef typename implementation_defined::const_local_iterator local_iterator;
+        typedef typename implementation_defined::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)
+        {
+        }
+
+        template <class InputIterator>
+        unordered_multiset(InputIterator f, InputIterator l,
+                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(f, l, n, hf, eql, a)
+        {
+        }
+
+    private:
+
+        typename implementation_defined::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.begin());
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator(base.begin());
+        }
+
+        iterator end()
+        {
+            return iterator(base.end());
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator(base.end());
+        }
+
+        // modifiers
+
+        iterator insert(const value_type& obj)
+        {
+            return iterator(base.insert_equivalent(obj));
+        }
+
+        iterator insert(const_iterator hint, const value_type& obj)
+        {
+            return iterator(base.insert_equivalent(get(hint), obj));
+        }
+
+        template <class InputIterator>
+            void insert(InputIterator first, InputIterator last)
+        {
+            base.insert(first, last);
+        }
+
+        iterator erase(const_iterator position)
+        {
+            return iterator(base.erase(get(position)));
+        }
+
+        size_type erase(const key_type& k)
+        {
+            return base.erase(k);
+        }
+
+        iterator erase(const_iterator first, const_iterator last)
+        {
+            return iterator(base.erase(get(first), get(last)));
+        }
+
+        void clear()
+        {
+            base.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
+
+        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.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.begin(n));
+        }
+
+        const_local_iterator begin(size_type n) const
+        {
+            return const_local_iterator(base.begin(n));
+        }
+
+        local_iterator end(size_type n)
+        {
+            return local_iterator(base.end(n));
+        }
+
+        const_local_iterator end(size_type n) const
+        {
+            return const_local_iterator(base.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);
+        }
+    }; // class template unordered_multiset
+
+    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)
+    {
+        m1.swap(m2);
+    }
+
+} // namespace boost
+
+#endif // BOOST_UNORDERED_SET_HPP_INCLUDED